kollabor 0.4.9__py3-none-any.whl → 0.4.15__py3-none-any.whl

core/io/status_renderer.py

@@ -1,25 +1,23 @@
+"""Status rendering system for terminal applications.
+
+This module provides block-based status rendering for terminal applications
+with plugin-configurable views and navigation.
+"""
+
 import re
 import logging
 import sys
 from dataclasses import dataclass
-from enum import Enum
 from typing import List, Dict, Any, Optional, Callable
 
+from .visual_effects import ColorPalette
+
 logger = logging.getLogger(__name__)
 
 # Platform check for keyboard shortcut display
 IS_WINDOWS = sys.platform == "win32"
 
 
-class StatusFormat(Enum):
-    """Status area formatting styles."""
-
-    COMPACT = "compact"
-    DETAILED = "detailed"
-    MINIMAL = "minimal"
-    BRACKETED = "bracketed"
-
-
 @dataclass
 class BlockConfig:
     """Configuration for a single status block."""
@@ -40,146 +38,6 @@ class StatusViewConfig:
     blocks: List[BlockConfig]  # Block layout configuration
 
 
-@dataclass
-class StatusMetric:
-    """Represents a single status metric."""
-
-    key: str
-    value: Any
-    format_type: str = (
-        "default"  # "number", "boolean", "time", "ratio", "percentage"
-    )
-    color_hint: Optional[str] = None
-    priority: int = 0
-
-    def format_value(self) -> str:
-        """Format the value based on its type."""
-        if self.format_type == "boolean":
-            return "Yes" if self.value else "No"
-        elif self.format_type == "time":
-            if isinstance(self.value, (int, float)):
-                return f"{self.value:.1f}s"
-            return str(self.value)
-        elif self.format_type == "ratio":
-            if isinstance(self.value, tuple) and len(self.value) == 2:
-                return f"{self.value[0]}/{self.value[1]}"
-            return str(self.value)
-        elif self.format_type == "percentage":
-            if isinstance(self.value, (int, float)):
-                return f"{self.value:.1f}%"
-            return str(self.value)
-        elif self.format_type == "number":
-            if isinstance(self.value, int) and self.value >= 1000:
-                # Add comma separators for large numbers
-                return f"{self.value:,}"
-            return str(self.value)
-        else:
-            return str(self.value)
-
-    def get_display_text(self) -> str:
-        """Get formatted display text for this metric."""
-        formatted_value = self.format_value()
-        return f"{self.key}: {formatted_value}"
-
-
-class StatusAreaManager:
-    """Manages individual status areas and their content."""
-
-    def __init__(self, area_name: str):
-        """Initialize status area manager.
-
-        Args:
-            area_name: Name of the status area (A, B, C).
-        """
-        self.area_name = area_name
-        self.metrics: Dict[str, StatusMetric] = {}
-        self.custom_lines: List[str] = []
-        self.format_style = StatusFormat.BRACKETED
-
-    def add_metric(self, metric: StatusMetric) -> None:
-        """Add or update a status metric.
-
-        Args:
-            metric: StatusMetric to add.
-        """
-        self.metrics[metric.key] = metric
-
-    def update_metric(self, key: str, value: Any, **kwargs) -> None:
-        """Update an existing metric or create a new one.
-
-        Args:
-            key: Metric key.
-            value: New value.
-            **kwargs: Additional metric properties.
-        """
-        if key in self.metrics:
-            self.metrics[key].value = value
-            for attr, val in kwargs.items():
-                if hasattr(self.metrics[key], attr):
-                    setattr(self.metrics[key], attr, val)
-        else:
-            self.add_metric(StatusMetric(key, value, **kwargs))
-
-    def remove_metric(self, key: str) -> None:
-        """Remove a metric from the status area.
-
-        Args:
-            key: Metric key to remove.
-        """
-        self.metrics.pop(key, None)
-
-    def add_custom_line(self, line: str) -> None:
-        """Add a custom formatted line to the status area.
-
-        Args:
-            line: Custom line text.
-        """
-        self.custom_lines.append(line)
-
-    def clear_custom_lines(self) -> None:
-        """Clear all custom lines."""
-        self.custom_lines.clear()
-
-    def get_formatted_lines(self, colorizer_func=None) -> List[str]:
-        """Get formatted lines for display.
-
-        Args:
-            colorizer_func: Optional function to apply colors to text.
-
-        Returns:
-            List of formatted status lines.
-        """
-        lines = []
-
-        # Add metric lines (sorted by priority)
-        sorted_metrics = sorted(
-            self.metrics.values(), key=lambda m: m.priority, reverse=True
-        )
-        for metric in sorted_metrics:
-            line = metric.get_display_text()
-
-            # Apply color hints if specified
-            if metric.color_hint and colorizer_func:
-                line = colorizer_func(line)
-            elif colorizer_func:
-                line = colorizer_func(line)
-
-            lines.append(line)
-
-        # Add custom lines
-        for line in self.custom_lines:
-            if colorizer_func:
-                line = colorizer_func(line)
-            lines.append(line)
-
-        return lines
-
-    def clear(self) -> None:
-        """Clear all metrics and custom lines."""
-        self.metrics.clear()
-        self.custom_lines.clear()
-
-
 class StatusViewRegistry:
     """Registry for plugin-configurable status views with navigation."""
 
@@ -203,98 +61,122 @@ class StatusViewRegistry:
             plugin_name: Name of the plugin registering the view.
             config: StatusViewConfig for the new view.
         """
-        # Add the view and sort by priority
         self.views.append(config)
         self.views.sort(key=lambda v: v.priority, reverse=True)
 
         logger.info(
-            f"Registered status view '{config.name}' from plugin '{plugin_name}' with priority {config.priority}"
+            f"Registered status view '{config.name}' from plugin '{plugin_name}' "
+            f"with priority {config.priority}"
         )
 
-    def cycle_next(self) -> Optional[StatusViewConfig]:
-        """Navigate to next status view.
+    def _view_has_content(self, view: StatusViewConfig) -> bool:
+        """Check if a view has any content to display."""
+        for block in view.blocks:
+            try:
+                content = block.content_provider()
+                if content:
+                    return True
+            except Exception:
+                pass
+        return False
 
-        Returns:
-            New current view config, or None if no views.
-        """
+    def cycle_next(self) -> Optional[StatusViewConfig]:
+        """Navigate to next status view (skips empty views)."""
         if not self.views:
             return None
 
-        self.current_index = (self.current_index + 1) % len(self.views)
-        current_view = self.views[self.current_index]
+        start_index = self.current_index
+        for _ in range(len(self.views)):
+            self.current_index = (self.current_index + 1) % len(self.views)
+            current_view = self.views[self.current_index]
 
-        # Fire status view changed event
-        if self.event_bus:
-            try:
-                # Import here to avoid circular imports
-                from ..events.models import EventType, Event
+            if self._view_has_content(current_view):
+                if self.event_bus:
+                    try:
+                        from ..events.models import EventType, Event
 
-                event = Event(
-                    type=EventType.STATUS_VIEW_CHANGED,
-                    data={"view_name": current_view.name, "direction": "next"},
-                    source="status_view_registry",
-                )
-                self.event_bus.fire_event(event)
-            except Exception as e:
-                logger.warning(f"Failed to fire STATUS_VIEW_CHANGED event: {e}")
+                        event = Event(
+                            type=EventType.STATUS_VIEW_CHANGED,
+                            data={"view_name": current_view.name, "direction": "next"},
+                            source="status_view_registry",
+                        )
+                        self.event_bus.fire_event(event)
+                    except Exception as e:
+                        logger.warning(f"Failed to fire STATUS_VIEW_CHANGED event: {e}")
 
-        logger.debug(f"Cycled to next status view: '{current_view.name}'")
-        return current_view
+                logger.debug(f"Cycled to next status view: '{current_view.name}'")
+                return current_view
 
-    def cycle_previous(self) -> Optional[StatusViewConfig]:
-        """Navigate to previous status view.
+        self.current_index = start_index
+        return self.views[self.current_index] if self.views else None
 
-        Returns:
-            New current view config, or None if no views.
-        """
+    def cycle_previous(self) -> Optional[StatusViewConfig]:
+        """Navigate to previous status view (skips empty views)."""
         if not self.views:
             return None
 
-        self.current_index = (self.current_index - 1) % len(self.views)
-        current_view = self.views[self.current_index]
+        start_index = self.current_index
+        for _ in range(len(self.views)):
+            self.current_index = (self.current_index - 1) % len(self.views)
+            current_view = self.views[self.current_index]
+
+            if self._view_has_content(current_view):
+                if self.event_bus:
+                    try:
+                        from ..events.models import EventType, Event
+
+                        event = Event(
+                            type=EventType.STATUS_VIEW_CHANGED,
+                            data={
+                                "view_name": current_view.name,
+                                "direction": "previous",
+                            },
+                            source="status_view_registry",
+                        )
+                        self.event_bus.fire_event(event)
+                    except Exception as e:
+                        logger.warning(f"Failed to fire STATUS_VIEW_CHANGED event: {e}")
 
-        # Fire status view changed event
-        if self.event_bus:
-            try:
-                # Import here to avoid circular imports
-                from ..events.models import EventType, Event
-
-                event = Event(
-                    type=EventType.STATUS_VIEW_CHANGED,
-                    data={
-                        "view_name": current_view.name,
-                        "direction": "previous",
-                    },
-                    source="status_view_registry",
-                )
-                self.event_bus.fire_event(event)
-            except Exception as e:
-                logger.warning(f"Failed to fire STATUS_VIEW_CHANGED event: {e}")
+                logger.debug(f"Cycled to previous status view: '{current_view.name}'")
+                return current_view
 
-        logger.debug(f"Cycled to previous status view: '{current_view.name}'")
-        return current_view
+        self.current_index = start_index
+        return self.views[self.current_index] if self.views else None
 
     def get_current_view(self) -> Optional[StatusViewConfig]:
-        """Get the currently active status view.
-
-        Returns:
-            Current view config, or None if no views registered.
-        """
+        """Get the currently active status view."""
         if not self.views:
             return None
         return self.views[self.current_index]
 
     def get_view_count(self) -> int:
-        """Get total number of registered views."""
-        return len(self.views)
+        """Get total number of views with content."""
+        return sum(1 for view in self.views if self._view_has_content(view))
+
+    def get_current_view_index(self) -> int:
+        """Get 1-indexed position of current view among views with content."""
+        if not self.views:
+            return 0
+        current_view = self.views[self.current_index]
+        index = 0
+        for view in self.views:
+            if self._view_has_content(view):
+                index += 1
+                if view is current_view:
+                    return index
+        return index
 
     def get_view_names(self) -> List[str]:
         """Get names of all registered views."""
         return [view.name for view in self.views]
 
+    def get_active_view_names(self) -> List[str]:
+        """Get names of views with content."""
+        return [view.name for view in self.views if self._view_has_content(view)]
+
 
 class StatusRenderer:
-    """Main status rendering system coordinating multiple areas."""
+    """Block-based status rendering system."""
 
     def __init__(
         self,
@@ -305,79 +187,18 @@ class StatusRenderer:
 
         Args:
             terminal_width: Terminal width for layout calculations.
-            status_registry: Optional status view registry for block-based rendering.
+            status_registry: Status view registry for block-based rendering.
         """
         self.terminal_width = terminal_width
         self.status_registry = status_registry
-
-        # Create status area managers (legacy compatibility)
-        self.areas: Dict[str, StatusAreaManager] = {
-            "A": StatusAreaManager("A"),
-            "B": StatusAreaManager("B"),
-            "C": StatusAreaManager("C"),
-        }
-
-        # Rendering configuration
-        self.bracket_style = {
-            "open": "",
-            "close": "",
-            "color": "",
-        }  # No brackets
-        self.spacing = (
-            4  # Spacing between columns (increased for clarity without separator)
-        )
-        self.separator_style = ""  # No separator - clean minimal aesthetic
-
-    def get_area(self, area_name: str) -> Optional[StatusAreaManager]:
-        """Get status area manager by name.
-
-        Args:
-            area_name: Area name (A, B, or C).
-
-        Returns:
-            StatusAreaManager instance or None.
-        """
-        return self.areas.get(area_name.upper())
-
-    def update_area_content(self, area_name: str, content: List[str]) -> None:
-        """Update area content with raw lines (backward compatibility).
-
-        Args:
-            area_name: Area name.
-            content: List of content lines.
-        """
-        area = self.get_area(area_name)
-        if area:
-            area.clear()
-            for line in content:
-                area.add_custom_line(line)
+        self.spacing = 4  # Spacing between columns
 
     def set_terminal_width(self, width: int) -> None:
-        """Update terminal width for layout calculations.
-
-        Args:
-            width: New terminal width.
-        """
+        """Update terminal width for layout calculations."""
         self.terminal_width = width
 
     def render_horizontal_layout(self, colorizer_func=None) -> List[str]:
-        """Render status areas in horizontal (column) layout.
-
-        Args:
-            colorizer_func: Optional function to apply colors to text.
-
-        Returns:
-            List of formatted status lines.
-        """
-        # Use block-based rendering if registry is available and has views
-        if self.status_registry and self.status_registry.get_view_count() > 0:
-            return self._render_block_layout(colorizer_func)
-
-        # Fallback to legacy area-based rendering
-        return self._render_legacy_layout(colorizer_func)
-
-    def _render_legacy_layout(self, colorizer_func=None) -> List[str]:
-        """Render legacy area-based layout for backwards compatibility.
+        """Render status views in horizontal layout.
 
         Args:
             colorizer_func: Optional function to apply colors to text.
@@ -385,237 +206,12 @@ class StatusRenderer:
         Returns:
             List of formatted status lines.
         """
-        # Get content for all areas
-        area_contents = {}
-        for name, area in self.areas.items():
-            content = area.get_formatted_lines(colorizer_func)
-            if content:
-                area_contents[name] = content
-
-        if not area_contents:
+        if not self.status_registry:
             return []
-
-        # Use three-column layout for wide terminals
-        if self.terminal_width >= 80:
-            return self._render_three_column_layout(area_contents, colorizer_func)
-        else:
-            return self._render_vertical_layout(area_contents, colorizer_func)
-
-    def _render_three_column_layout(
-        self, area_contents: Dict[str, List[str]], colorizer_func=None
-    ) -> List[str]:
-        """Render three-column layout for wide terminals.
-
-        Args:
-            area_contents: Dictionary of area contents.
-            colorizer_func: Optional colorizer function.
-
-        Returns:
-            List of formatted lines.
-        """
-        lines = []
-
-        # Improved column width calculation
-        # Reserve space for brackets [text] and spacing between columns
-        brackets_overhead = 4  # 2 brackets + 2 padding spaces per column
-        total_spacing = (3 - 1) * self.spacing  # spacing between 3 columns
-        available_width = self.terminal_width - total_spacing
-        column_width = max(15, (available_width - (3 * brackets_overhead)) // 3)
-
-        # Get content for areas A, B, C in order
-        area_names = ["A", "B", "C"]
-        area_data = []
-        for area_name in area_names:
-            content = area_contents.get(area_name, [])
-            area_data.append(content)
-
-        # Find maximum lines across all areas
-        max_lines = max(len(content) for content in area_data) if area_data else 0
-
-        # Create each row with three columns
-        for line_idx in range(max_lines):
-            columns = []
-
-            for content in area_data:
-                if line_idx < len(content):
-                    text = content[line_idx]
-
-                    # Truncate if too long for column (account for brackets)
-                    visible_text = self._strip_ansi(text)
-                    max_text_width = column_width - 2  # Reserve space for brackets
-
-                    if len(visible_text) > max_text_width:
-                        # Smart truncation - preserve important parts
-                        if max_text_width > 3:
-                            truncated = self._truncate_with_ansi(
-                                text, max_text_width - 3
-                            )
-                            text = truncated + "..."
-                        else:
-                            text = "..."
-
-                    # Apply bracket formatting
-                    bracketed_text = self._apply_brackets(text)
-                    columns.append(bracketed_text)
-                else:
-                    columns.append("")  # Empty column
-
-            # Join columns with improved spacing
-            formatted_line = self._join_columns_improved(
-                columns, column_width + brackets_overhead
-            )
-
-            # Only add line if it has content
-            if formatted_line.strip():
-                lines.append(formatted_line.rstrip())
-
-        return lines
-
-    def _render_vertical_layout(
-        self, area_contents: Dict[str, List[str]], colorizer_func=None
-    ) -> List[str]:
-        """Render vertical layout for narrow terminals.
-
-        Args:
-            area_contents: Dictionary of area contents.
-            colorizer_func: Optional colorizer function.
-
-        Returns:
-            List of formatted lines.
-        """
-        lines = []
-
-        # Render each area vertically
-        for area_name in ["A", "B", "C"]:
-            content = area_contents.get(area_name, [])
-            for line in content:
-                if line.strip():
-                    bracketed_line = self._apply_brackets(line)
-                    lines.append(bracketed_line)
-
-        return lines
-
-    def _apply_brackets(self, text: str) -> str:
-        """Apply bracket styling to text.
-
-        Args:
-            text: Text to apply brackets to.
-
-        Returns:
-            Text with brackets applied.
-        """
-        bracket_color = self.bracket_style["color"]
-        reset = "\033[0m"
-        open_bracket = self.bracket_style["open"]
-        close_bracket = self.bracket_style["close"]
-
-        return f"{bracket_color}{open_bracket}{reset}{text}{bracket_color}{close_bracket}{reset}"
-
-    def _join_columns(self, columns: List[str], column_width: int) -> str:
-        """Join columns with proper spacing and alignment (legacy method).
-
-        Args:
-            columns: List of column strings.
-            column_width: Width of each column.
-
-        Returns:
-            Joined line string.
-        """
-        return self._join_columns_improved(columns, column_width)
-
-    def _join_columns_improved(self, columns: List[str], column_width: int) -> str:
-        """Join columns with improved spacing and alignment.
-
-        Args:
-            columns: List of column strings.
-            column_width: Width of each column (including brackets).
-
-        Returns:
-            Joined line string.
-        """
-        formatted_line = ""
-
-        for i, col in enumerate(columns):
-            if col:
-                # Add the column content
-                formatted_line += col
-
-                # Calculate padding needed
-                visible_length = len(self._strip_ansi(col))
-                padding = max(0, column_width - visible_length)
-
-                # Add padding only if not the last column
-                if i < len(columns) - 1:
-                    formatted_line += " " * padding
-                    # Add inter-column spacing
-                    formatted_line += " " * self.spacing
-            else:
-                # Empty column - add spacing if not last
-                if i < len(columns) - 1:
-                    formatted_line += " " * column_width
-                    formatted_line += " " * self.spacing
-
-        return formatted_line
-
-    def _strip_ansi(self, text: str) -> str:
-        """Remove ANSI escape codes from text.
-
-        Args:
-            text: Text with potential ANSI codes.
-
-        Returns:
-            Text with ANSI codes removed.
-        """
-        return re.sub(r"\033\[[0-9;]*m", "", text)
-
-    def _truncate_with_ansi(self, text: str, max_length: int) -> str:
-        """Truncate text while preserving ANSI codes.
-
-        Args:
-            text: Text to truncate.
-            max_length: Maximum visible length.
-
-        Returns:
-            Truncated text with ANSI codes preserved.
-        """
-        result = ""
-        visible_count = 0
-        i = 0
-
-        while i < len(text) and visible_count < max_length:
-            # Check for ANSI escape sequence
-            if (
-                text[i : i + 1] == "\033"
-                and i + 1 < len(text)
-                and text[i + 1] == "["
-            ):
-                # Find end of ANSI sequence
-                end = i + 2
-                while end < len(text) and text[end] not in "mhlABCDEFGHJKSTfimpsuI":
-                    end += 1
-                if end < len(text):
-                    end += 1
-
-                # Add the entire ANSI sequence
-                result += text[i:end]
-                i = end
-            else:
-                # Regular character
-                result += text[i]
-                visible_count += 1
-                i += 1
-
-        return result
+        return self._render_block_layout(colorizer_func)
 
     def _render_block_layout(self, colorizer_func=None) -> List[str]:
-        """Render flexible block-based layout using StatusViewRegistry.
-
-        Args:
-            colorizer_func: Optional function to apply colors to text.
-
-        Returns:
-            List of formatted status lines.
-        """
+        """Render flexible block-based layout using StatusViewRegistry."""
         if not self.status_registry:
             return []
 
@@ -649,65 +245,33 @@ class StatusRenderer:
         block_contents.sort(key=lambda b: b["priority"], reverse=True)
 
         # Calculate block layout
-        lines = self._calculate_and_render_blocks(block_contents, colorizer_func)
+        total_width = sum(block["width_fraction"] for block in block_contents)
+        if total_width <= 1.0:
+            lines = self._render_single_row_blocks(block_contents, colorizer_func)
+        else:
+            lines = self._render_multi_row_blocks(block_contents, colorizer_func)
 
-        # Add cycling hint if multiple views are available
+        # Add cycling hint if multiple views with content are available
         view_count = self.status_registry.get_view_count()
         if view_count > 1:
-            current_index = (
-                self.status_registry.current_index + 1
-            )  # 1-indexed for display
-            # Use INFO_CYAN from Neon Minimal palette
-            # Use platform-appropriate modifier key name
+            current_index = self.status_registry.get_current_view_index()
             mod_key = "Alt" if IS_WINDOWS else "Opt"
-            hint = f"\033[38;2;6;182;212m({mod_key}+, / {mod_key}+. to cycle • View {current_index}/{view_count}: {current_view.name})\033[0m"
+            hint = (
+                f"{ColorPalette.INFO_CYAN}({mod_key}+Left/Right to cycle • "
+                f"View {current_index}/{view_count}: {current_view.name})"
+                f"{ColorPalette.RESET}"
+            )
             lines.append(hint)
 
         return lines
 
-    def _calculate_and_render_blocks(
-        self, block_contents: List[Dict], colorizer_func=None
-    ) -> List[str]:
-        """Calculate block layout and render status lines.
-
-        Args:
-            block_contents: List of block content dictionaries.
-            colorizer_func: Optional colorizer function.
-
-        Returns:
-            List of formatted status lines.
-        """
-        if not block_contents:
-            return []
-
-        # For now, implement horizontal layout similar to the legacy system
-        # This can be enhanced later for more complex layouts
-
-        # Calculate how many blocks can fit horizontally
-        total_width_needed = sum(block["width_fraction"] for block in block_contents)
-
-        if total_width_needed <= 1.0:
-            # All blocks fit in one row
-            return self._render_single_row_blocks(block_contents, colorizer_func)
-        else:
-            # Need multiple rows or vertical layout
-            return self._render_multi_row_blocks(block_contents, colorizer_func)
-
     def _render_single_row_blocks(
         self, block_contents: List[Dict], colorizer_func=None
     ) -> List[str]:
-        """Render blocks in a single horizontal row.
-
-        Args:
-            block_contents: List of block content dictionaries.
-            colorizer_func: Optional colorizer function.
-
-        Returns:
-            List of formatted status lines.
-        """
+        """Render blocks in a single horizontal row."""
         lines = []
 
-        # Calculate actual column widths
+        # Calculate column widths
         total_spacing = (
             (len(block_contents) - 1) * self.spacing
             if len(block_contents) > 1
@@ -718,7 +282,7 @@ class StatusRenderer:
         column_widths = []
         for block in block_contents:
             width = int(available_width * block["width_fraction"])
-            column_widths.append(max(10, width))  # Minimum width of 10
+            column_widths.append(max(10, width))
 
         # Find maximum lines across all blocks
         max_lines = (
@@ -735,8 +299,8 @@ class StatusRenderer:
                 if line_idx < len(block["content"]):
                     text = block["content"][line_idx]
 
-                    # Apply colorizer
-                    if colorizer_func:
+                    # Skip colorizer for pre-colored content
+                    if colorizer_func and "\033[" not in text:
                         text = colorizer_func(text)
 
                     # Truncate if too long
@@ -745,30 +309,23 @@ class StatusRenderer:
 
                     if len(visible_text) > max_width:
                         if max_width > 3:
-                            text = (
-                                self._truncate_with_ansi(text, max_width - 3) + "..."
-                            )
+                            text = self._truncate_with_ansi(text, max_width - 3) + "..."
                         else:
                             text = "..."
 
                     columns.append(text)
                 else:
-                    columns.append("")  # Empty column
+                    columns.append("")
 
-            # Join columns with smart spacing (no separator needed)
+            # Join columns with spacing
             formatted_line = ""
             for i, col in enumerate(columns):
                 formatted_line += col
 
-                # Add spacing between columns (not after last)
-                if i < len(columns) - 1 and any(
-                    columns[i + 1 :]
-                ):  # Only add spacing if there are more non-empty columns
-                    # Pad current column to its width
+                if i < len(columns) - 1 and any(columns[i + 1:]):
                     visible_length = len(self._strip_ansi(col))
                     padding = max(0, column_widths[i] - visible_length)
                     formatted_line += " " * padding
-                    # Add clean inter-column spacing
                     formatted_line += " " * self.spacing
 
             if formatted_line.strip():
@@ -779,31 +336,20 @@ class StatusRenderer:
     def _render_multi_row_blocks(
         self, block_contents: List[Dict], colorizer_func=None
     ) -> List[str]:
-        """Render blocks that don't fit in a single row.
-
-        Args:
-            block_contents: List of block content dictionaries.
-            colorizer_func: Optional colorizer function.
-
-        Returns:
-            List of formatted status lines.
-        """
+        """Render blocks that don't fit in a single row."""
         lines = []
 
-        # For now, render each block on its own line(s)
-        # This is a simple fallback - can be enhanced later
         for block in block_contents:
             for content_line in block["content"]:
-                if colorizer_func:
+                # Skip colorizer for pre-colored content
+                if colorizer_func and "\033[" not in content_line:
                     content_line = colorizer_func(content_line)
 
                 # Truncate if too long
                 visible_text = self._strip_ansi(content_line)
                 if len(visible_text) > self.terminal_width - 3:
                     content_line = (
-                        self._truncate_with_ansi(
-                            content_line, self.terminal_width - 6
-                        )
+                        self._truncate_with_ansi(content_line, self.terminal_width - 6)
                         + "..."
                     )
 
@@ -811,35 +357,29 @@ class StatusRenderer:
 
         return lines
 
-    def get_status_summary(self) -> Dict[str, Any]:
-        """Get summary of status rendering state.
+    def _strip_ansi(self, text: str) -> str:
+        """Remove ANSI escape codes from text."""
+        return re.sub(r"\033\[[0-9;]*m", "", text)
 
-        Returns:
-            Dictionary with status information.
-        """
-        summary = {
-            "terminal_width": self.terminal_width,
-            "areas": {
-                name: {
-                    "metrics_count": len(area.metrics),
-                    "custom_lines_count": len(area.custom_lines),
-                    "total_lines": len(area.get_formatted_lines()),
-                }
-                for name, area in self.areas.items()
-            },
-            "bracket_style": self.bracket_style,
-            "spacing": self.spacing,
-            "separator_style": self.separator_style,
-        }
-
-        # Add status registry information if available
-        if self.status_registry:
-            current_view = self.status_registry.get_current_view()
-            summary["status_registry"] = {
-                "view_count": self.status_registry.get_view_count(),
-                "view_names": self.status_registry.get_view_names(),
-                "current_view": current_view.name if current_view else None,
-                "current_blocks": (len(current_view.blocks) if current_view else 0),
-            }
-
-        return summary
+    def _truncate_with_ansi(self, text: str, max_length: int) -> str:
+        """Truncate text while preserving ANSI codes."""
+        result = ""
+        visible_count = 0
+        i = 0
+
+        while i < len(text) and visible_count < max_length:
+            if text[i:i + 1] == "\033" and i + 1 < len(text) and text[i + 1] == "[":
+                # Find end of ANSI sequence
+                end = i + 2
+                while end < len(text) and text[end] not in "mhlABCDEFGHJKSTfimpsuI":
+                    end += 1
+                if end < len(text):
+                    end += 1
+                result += text[i:end]
+                i = end
+            else:
+                result += text[i]
+                visible_count += 1
+                i += 1
+
+        return result