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

core/io/visual_effects.py

@@ -1,11 +1,195 @@
-"""Visual effects system for terminal rendering."""
+"""Visual effects system for terminal rendering.
 
+This module provides comprehensive visual effects for terminal rendering,
+including gradient effects, shimmer animations, color palettes,
+and banner generation.
+"""
+
+import os
 import re
 from dataclasses import dataclass, field
 from enum import Enum
 from typing import List, Tuple, Dict, Any
 
 
+class ColorSupport(Enum):
+    """Terminal color support levels."""
+
+    NONE = 0  # No color support
+    BASIC = 1  # 16 colors (4-bit)
+    EXTENDED = 2  # 256 colors (8-bit)
+    TRUE_COLOR = 3  # 16 million colors (24-bit RGB)
+
+
+def detect_color_support() -> ColorSupport:
+    """Detect terminal color support level.
+
+    Checks environment variables and terminal type to determine
+    the maximum color depth supported.
+
+    Returns:
+        ColorSupport level for current terminal.
+    """
+    # Check for explicit no-color request
+    if os.environ.get("NO_COLOR") or os.environ.get("TERM") == "dumb":
+        return ColorSupport.NONE
+
+    # Check for explicit true color support
+    colorterm = os.environ.get("COLORTERM", "").lower()
+    if colorterm in ("truecolor", "24bit"):
+        return ColorSupport.TRUE_COLOR
+
+    # Check terminal type for known true color support
+    term = os.environ.get("TERM", "").lower()
+    term_program = os.environ.get("TERM_PROGRAM", "").lower()
+
+    # Terminals known to support true color
+    true_color_terms = (
+        "iterm.app",
+        "iterm2",
+        "vscode",
+        "hyper",
+        "alacritty",
+        "kitty",
+        "wezterm",
+        "rio",
+    )
+    if term_program in true_color_terms:
+        return ColorSupport.TRUE_COLOR
+
+    # Check TERM for true color indicators
+    if "truecolor" in term or "24bit" in term or "direct" in term:
+        return ColorSupport.TRUE_COLOR
+
+    # Modern terminal emulators with 256+ color support in TERM
+    if "256color" in term or "256" in term:
+        return ColorSupport.EXTENDED
+
+    # xterm and similar usually support 256 colors
+    if term.startswith(("xterm", "screen", "tmux", "rxvt")):
+        return ColorSupport.EXTENDED
+
+    # Apple Terminal.app - only 256 color, NOT true color
+    if term_program == "apple_terminal":
+        return ColorSupport.EXTENDED
+
+    # Basic color support for other terminals
+    if term:
+        return ColorSupport.BASIC
+
+    return ColorSupport.NONE
+
+
+# Global color support level - detected once at import
+_COLOR_SUPPORT: ColorSupport | None = None
+
+
+def get_color_support() -> ColorSupport:
+    """Get cached color support level.
+
+    Checks KOLLABOR_COLOR_MODE env var first for manual override:
+      - "truecolor" or "24bit" -> TRUE_COLOR
+      - "256" or "256color"    -> EXTENDED
+      - "16" or "basic"        -> BASIC
+      - "none" or "off"        -> NONE
+
+    Returns:
+        ColorSupport level for current terminal.
+    """
+    global _COLOR_SUPPORT
+    if _COLOR_SUPPORT is None:
+        # Check for manual override
+        override = os.environ.get("KOLLABOR_COLOR_MODE", "").lower()
+        if override in ("truecolor", "24bit", "true"):
+            _COLOR_SUPPORT = ColorSupport.TRUE_COLOR
+        elif override in ("256", "256color", "extended"):
+            _COLOR_SUPPORT = ColorSupport.EXTENDED
+        elif override in ("16", "basic"):
+            _COLOR_SUPPORT = ColorSupport.BASIC
+        elif override in ("none", "off", "no"):
+            _COLOR_SUPPORT = ColorSupport.NONE
+        else:
+            _COLOR_SUPPORT = detect_color_support()
+    return _COLOR_SUPPORT
+
+
+def set_color_support(level: ColorSupport) -> None:
+    """Manually set color support level.
+
+    Args:
+        level: ColorSupport level to use.
+    """
+    global _COLOR_SUPPORT
+    _COLOR_SUPPORT = level
+
+
+def reset_color_support() -> None:
+    """Reset color support to re-detect on next call."""
+    global _COLOR_SUPPORT
+    _COLOR_SUPPORT = None
+
+
+def rgb_to_256(r: int, g: int, b: int) -> int:
+    """Convert RGB color to nearest 256-color palette index.
+
+    Uses the 6x6x6 color cube (indices 16-231) for colored values,
+    or grayscale ramp (indices 232-255) for near-gray colors.
+
+    Args:
+        r: Red component (0-255)
+        g: Green component (0-255)
+        b: Blue component (0-255)
+
+    Returns:
+        256-color palette index (0-255)
+    """
+    # Check if color is near grayscale
+    if abs(r - g) < 10 and abs(g - b) < 10 and abs(r - b) < 10:
+        # Use grayscale ramp (232-255, 24 shades)
+        gray = (r + g + b) // 3
+        if gray < 8:
+            return 16  # black
+        if gray > 248:
+            return 231  # white
+        return 232 + ((gray - 8) * 24) // 240
+
+    # Use 6x6x6 color cube (indices 16-231)
+    # Each component maps to 0-5
+    r_idx = (r * 6) // 256
+    g_idx = (g * 6) // 256
+    b_idx = (b * 6) // 256
+    return 16 + (36 * r_idx) + (6 * g_idx) + b_idx
+
+
+def color_code(r: int, g: int, b: int, bold: bool = False, dim: bool = False) -> str:
+    """Generate a foreground color escape code with automatic fallback.
+
+    Uses true color (24-bit) when supported, otherwise falls back
+    to 256-color palette.
+
+    Args:
+        r: Red component (0-255)
+        g: Green component (0-255)
+        b: Blue component (0-255)
+        bold: Add bold attribute
+        dim: Add dim attribute
+
+    Returns:
+        ANSI escape sequence for the color.
+    """
+    prefix = ""
+    if bold:
+        prefix = "\033[1m"
+    elif dim:
+        prefix = "\033[2m"
+
+    if get_color_support() == ColorSupport.TRUE_COLOR:
+        return f"{prefix}\033[38;2;{r};{g};{b}m"
+    else:
+        idx = rgb_to_256(r, g, b)
+        return f"{prefix}\033[38;5;{idx}m"
+
+
 class EffectType(Enum):
     """Types of visual effects."""
 
@@ -28,89 +212,127 @@ class EffectConfig:
     colors: List[str] = field(default_factory=list)
 
 
-class ColorPalette:
-    """Color palette definitions for various effects - RGB True Color (24-bit)."""
-
-    # Standard colors
+# Color definitions as (r, g, b, modifier) tuples
+# modifier: None=normal, 'bold'=bright, 'dim'=dim
+_COLOR_DEFINITIONS = {
+    # Basic colors
+    "WHITE": (220, 220, 220, None),
+    "BRIGHT_WHITE": (255, 255, 255, "bold"),
+    "BLACK": (0, 0, 0, None),
+    # Red variants
+    "DIM_RED": (205, 49, 49, "dim"),
+    "RED": (205, 49, 49, None),
+    "BRIGHT_RED": (241, 76, 76, "bold"),
+    # Green variants
+    "DIM_GREEN": (13, 188, 121, "dim"),
+    "GREEN": (13, 188, 121, None),
+    "BRIGHT_GREEN": (35, 209, 139, "bold"),
+    # Yellow variants
+    "DIM_YELLOW": (229, 192, 123, "dim"),
+    "YELLOW": (229, 192, 123, None),
+    "BRIGHT_YELLOW": (245, 223, 77, "bold"),
+    # Blue variants
+    "DIM_BLUE": (36, 114, 200, "dim"),
+    "BLUE": (36, 114, 200, None),
+    "BRIGHT_BLUE": (59, 142, 234, "bold"),
+    "NORMAL_BLUE": (100, 149, 237, None),
+    # Magenta variants
+    "DIM_MAGENTA": (188, 63, 188, "dim"),
+    "MAGENTA": (188, 63, 188, None),
+    "BRIGHT_MAGENTA": (214, 112, 214, "bold"),
+    # Cyan variants
+    "DIM_CYAN": (17, 168, 205, "dim"),
+    "CYAN": (17, 168, 205, None),
+    "BRIGHT_CYAN": (41, 184, 219, "bold"),
+    # Grey variants
+    "DIM_GREY": (128, 128, 128, "dim"),
+    "GREY": (128, 128, 128, None),
+    "BRIGHT_GREY": (169, 169, 169, "bold"),
+    # Extended bright colors
+    "BRIGHT_CYAN_256": (0, 255, 255, "bold"),
+    "BRIGHT_BLUE_256": (94, 156, 255, "bold"),
+    "BRIGHT_GREEN_256": (90, 247, 142, "bold"),
+    "BRIGHT_YELLOW_256": (255, 231, 76, "bold"),
+    "BRIGHT_MAGENTA_256": (255, 92, 205, "bold"),
+    "BRIGHT_RED_256": (255, 85, 85, "bold"),
+    # Neon Minimal Palette - Lime
+    "LIME": (163, 230, 53, None),
+    "BRIGHT_LIME": (163, 230, 53, "bold"),
+    "LIME_LIGHT": (190, 242, 100, None),
+    "LIME_DARK": (132, 204, 22, None),
+    # Info: Cyan
+    "INFO_CYAN": (6, 182, 212, None),
+    "INFO_CYAN_LIGHT": (34, 211, 238, None),
+    "INFO_CYAN_DARK": (8, 145, 178, None),
+    # Warning: Gold
+    "WARNING_GOLD": (234, 179, 8, None),
+    "WARNING_GOLD_LIGHT": (253, 224, 71, None),
+    "WARNING_GOLD_DARK": (202, 138, 4, None),
+    # Error: Red
+    "ERROR_RED": (239, 68, 68, None),
+    "ERROR_RED_LIGHT": (248, 113, 113, None),
+    "ERROR_RED_DARK": (220, 38, 38, None),
+    # Muted: Steel
+    "MUTED_STEEL": (113, 113, 122, None),
+    "DIM_STEEL": (113, 113, 122, "dim"),
+}
+
+
+def _make_color_code(r: int, g: int, b: int, modifier: str | None = None) -> str:
+    """Generate escape code for a color with automatic fallback.
+
+    Args:
+        r, g, b: RGB components (0-255)
+        modifier: 'bold', 'dim', or None
+
+    Returns:
+        ANSI escape sequence appropriate for terminal capability.
+    """
+    prefix = ""
+    if modifier == "bold":
+        prefix = "\033[1m"
+    elif modifier == "dim":
+        prefix = "\033[2m"
+
+    support = get_color_support()
+
+    if support == ColorSupport.NONE:
+        return prefix if prefix else ""
+
+    if support == ColorSupport.TRUE_COLOR:
+        return f"{prefix}\033[38;2;{r};{g};{b}m"
+    else:
+        # Use 256-color fallback
+        idx = rgb_to_256(r, g, b)
+        return f"{prefix}\033[38;5;{idx}m"
+
+
+class _ColorPaletteMeta(type):
+    """Metaclass that generates color codes dynamically based on terminal support."""
+
+    def __getattr__(cls, name: str) -> str:
+        if name in _COLOR_DEFINITIONS:
+            r, g, b, modifier = _COLOR_DEFINITIONS[name]
+            return _make_color_code(r, g, b, modifier)
+        raise AttributeError(f"ColorPalette has no color '{name}'")
+
+
+class ColorPalette(metaclass=_ColorPaletteMeta):
+    """Color palette with automatic terminal capability detection.
+
+    Colors are generated dynamically based on terminal support:
+    - TRUE_COLOR: Uses 24-bit RGB escape codes
+    - EXTENDED: Falls back to 256-color palette
+    - BASIC: Uses 16-color approximations
+    - NONE: Returns empty strings or just modifiers
+    """
+
+    # Standard modifiers (not affected by color support)
     RESET = "\033[0m"
     DIM = "\033[2m"
     BRIGHT = "\033[1m"
 
-    # Basic colors - RGB True Color
-    WHITE = "\033[38;2;220;220;220m"              # rgb(220, 220, 220)
-    BRIGHT_WHITE = "\033[1m\033[38;2;255;255;255m"  # Bold + rgb(255, 255, 255)
-    BLACK = "\033[38;2;0;0;0m"                    # rgb(0, 0, 0)
-
-    # Red variants - RGB True Color
-    DIM_RED = "\033[2m\033[38;2;205;49;49m"       # Dim + rgb(205, 49, 49)
-    RED = "\033[38;2;205;49;49m"                  # rgb(205, 49, 49)
-    BRIGHT_RED = "\033[1m\033[38;2;241;76;76m"    # Bold + rgb(241, 76, 76)
-
-    # Green variants - RGB True Color
-    DIM_GREEN = "\033[2m\033[38;2;13;188;121m"    # Dim + rgb(13, 188, 121)
-    GREEN = "\033[38;2;13;188;121m"               # rgb(13, 188, 121)
-    BRIGHT_GREEN = "\033[1m\033[38;2;35;209;139m" # Bold + rgb(35, 209, 139)
-
-    # Yellow variants - RGB True Color
-    DIM_YELLOW = "\033[2m\033[38;2;229;192;123m"  # Dim + rgb(229, 192, 123)
-    YELLOW = "\033[38;2;229;192;123m"             # rgb(229, 192, 123)
-    BRIGHT_YELLOW = "\033[1m\033[38;2;245;223;77m" # Bold + rgb(245, 223, 77)
-
-    # Blue variants - RGB True Color
-    DIM_BLUE = "\033[2m\033[38;2;36;114;200m"     # Dim + rgb(36, 114, 200)
-    BLUE = "\033[38;2;36;114;200m"                # rgb(36, 114, 200)
-    BRIGHT_BLUE = "\033[1m\033[38;2;59;142;234m"  # Bold + rgb(59, 142, 234)
-    NORMAL_BLUE = "\033[38;2;100;149;237m"        # rgb(100, 149, 237) - cornflower blue
-
-    # Magenta variants - RGB True Color
-    DIM_MAGENTA = "\033[2m\033[38;2;188;63;188m"  # Dim + rgb(188, 63, 188)
-    MAGENTA = "\033[38;2;188;63;188m"             # rgb(188, 63, 188)
-    BRIGHT_MAGENTA = "\033[1m\033[38;2;214;112;214m" # Bold + rgb(214, 112, 214)
-
-    # Cyan variants - RGB True Color
-    DIM_CYAN = "\033[2m\033[38;2;17;168;205m"     # Dim + rgb(17, 168, 205)
-    CYAN = "\033[38;2;17;168;205m"                # rgb(17, 168, 205)
-    BRIGHT_CYAN = "\033[1m\033[38;2;41;184;219m"  # Bold + rgb(41, 184, 219)
-
-    # Grey variants - RGB True Color
-    DIM_GREY = "\033[2m\033[38;2;128;128;128m"    # Dim + rgb(128, 128, 128)
-    GREY = "\033[38;2;128;128;128m"               # rgb(128, 128, 128)
-    BRIGHT_GREY = "\033[1m\033[38;2;169;169;169m" # Bold + rgb(169, 169, 169)
-
-    # Extended bright colors - RGB True Color (brighter versions)
-    BRIGHT_CYAN_256 = "\033[1m\033[38;2;0;255;255m"    # Bold + rgb(0, 255, 255)
-    BRIGHT_BLUE_256 = "\033[1m\033[38;2;94;156;255m"   # Bold + rgb(94, 156, 255)
-    BRIGHT_GREEN_256 = "\033[1m\033[38;2;90;247;142m"  # Bold + rgb(90, 247, 142)
-    BRIGHT_YELLOW_256 = "\033[1m\033[38;2;255;231;76m" # Bold + rgb(255, 231, 76)
-    BRIGHT_MAGENTA_256 = "\033[1m\033[38;2;255;92;205m" # Bold + rgb(255, 92, 205)
-    BRIGHT_RED_256 = "\033[1m\033[38;2;255;85;85m"     # Bold + rgb(255, 85, 85)
-
-    # Neon Minimal Palette - RGB True Color (24-bit)
-    # Primary: Lime Green #a3e635
-    LIME = "\033[38;2;163;230;53m"
-    LIME_LIGHT = "\033[38;2;190;242;100m"
-    LIME_DARK = "\033[38;2;132;204;22m"
-
-    # Info: Cyan #06b6d4
-    INFO_CYAN = "\033[38;2;6;182;212m"
-    INFO_CYAN_LIGHT = "\033[38;2;34;211;238m"
-    INFO_CYAN_DARK = "\033[38;2;8;145;178m"
-
-    # Warning: Gold #eab308
-    WARNING_GOLD = "\033[38;2;234;179;8m"
-    WARNING_GOLD_LIGHT = "\033[38;2;253;224;71m"
-    WARNING_GOLD_DARK = "\033[38;2;202;138;4m"
-
-    # Error: Bright Red #ef4444
-    ERROR_RED = "\033[38;2;239;68;68m"
-    ERROR_RED_LIGHT = "\033[38;2;248;113;113m"
-    ERROR_RED_DARK = "\033[38;2;220;38;38m"
-
-    # Muted: Steel #71717a
-    MUTED_STEEL = "\033[38;2;113;113;122m"
-    DIM_STEEL = "\033[2;38;2;113;113;122m"
-
-    # Grey gradient levels (256-color palette)
+    # Grey gradient levels (256-color palette indices)
     GREY_LEVELS = [255, 254, 253, 252, 251, 250]
 
     # Dim white gradient levels (bright white to subtle dim white)
@@ -119,19 +341,474 @@ class ColorPalette:
     # Lime green gradient scheme RGB values for ultra-smooth gradients
     DIM_SCHEME_COLORS = [
         (190, 242, 100),  # Bright lime (#bef264)
-        (175, 235, 80),  # Light lime
-        (163, 230, 53),  # Primary lime (#a3e635) - hero color!
-        (145, 210, 45),  # Medium lime
-        (132, 204, 22),  # Darker lime (#84cc16)
-        (115, 180, 18),  # Deep lime
-        (100, 160, 15),  # Strong lime
-        (115, 180, 18),  # Deep lime (return)
-        (132, 204, 22),  # Darker lime (return)
-        (163, 230, 53),  # Primary lime (return)
+        (175, 235, 80),   # Light lime
+        (163, 230, 53),   # Primary lime (#a3e635) - hero color!
+        (145, 210, 45),   # Medium lime
+        (132, 204, 22),   # Darker lime (#84cc16)
+        (115, 180, 18),   # Deep lime
+        (100, 160, 15),   # Strong lime
+        (115, 180, 18),   # Deep lime (return)
+        (132, 204, 22),   # Darker lime (return)
+        (163, 230, 53),   # Primary lime (return)
         (190, 242, 100),  # Bright lime
     ]
 
 
+# Powerline separator characters
+class Powerline:
+    """Powerline/Agnoster style separator characters."""
+
+    # Solid arrows
+    RIGHT = "\ue0b0"  #
+    LEFT = "\ue0b2"   #
+
+    # Thin arrows (for sub-segments)
+    RIGHT_THIN = "\ue0b1"  #
+    LEFT_THIN = "\ue0b3"   #
+
+    # Rounded
+    RIGHT_ROUND = "\ue0b4"  #
+    LEFT_ROUND = "\ue0b6"   #
+
+    # Flame/fire style
+    RIGHT_FLAME = "\ue0c0"  #
+    LEFT_FLAME = "\ue0c2"   #
+
+    # Pixelated
+    RIGHT_PIXEL = "\ue0c4"  #
+    LEFT_PIXEL = "\ue0c6"   #
+
+    # Ice/diagonal
+    RIGHT_ICE = "\ue0c8"    #
+    LEFT_ICE = "\ue0ca"     #
+
+
+def make_bg_color(r: int, g: int, b: int) -> str:
+    """Create background color escape code.
+
+    Args:
+        r, g, b: RGB values (0-255).
+
+    Returns:
+        ANSI escape code for background color.
+    """
+    support = get_color_support()
+
+    if support == ColorSupport.NONE:
+        return ""
+
+    if support == ColorSupport.TRUE_COLOR:
+        return f"\033[48;2;{r};{g};{b}m"
+    else:
+        # Use 256-color fallback
+        idx = rgb_to_256(r, g, b)
+        return f"\033[48;5;{idx}m"
+
+
+def make_fg_color(r: int, g: int, b: int) -> str:
+    """Create foreground color escape code.
+
+    Args:
+        r, g, b: RGB values (0-255).
+
+    Returns:
+        ANSI escape code for foreground color.
+    """
+    support = get_color_support()
+
+    if support == ColorSupport.NONE:
+        return ""
+
+    if support == ColorSupport.TRUE_COLOR:
+        return f"\033[38;2;{r};{g};{b}m"
+    else:
+        idx = rgb_to_256(r, g, b)
+        return f"\033[38;5;{idx}m"
+
+
+class AgnosterColors:
+    """Signature color scheme for agnoster segments - lime and cyan."""
+
+    # Lime palette (RGB tuples)
+    LIME = (163, 230, 53)
+    LIME_DARK = (132, 204, 22)
+    LIME_DARKER = (100, 160, 15)
+
+    # Cyan palette
+    CYAN = (6, 182, 212)
+    CYAN_DARK = (8, 145, 178)
+    CYAN_LIGHT = (34, 211, 238)
+
+    # Neutral backgrounds
+    BG_DARK = (30, 30, 30)
+    BG_MID = (50, 50, 50)
+    BG_LIGHT = (70, 70, 70)
+
+    # Text colors
+    TEXT_DARK = (20, 20, 20)
+    TEXT_LIGHT = (240, 240, 240)
+
+
+class ShimmerEffect:
+    """Handles shimmer animation effects."""
+
+    def __init__(self, speed: int = 3, wave_width: int = 4):
+        """Initialize shimmer effect.
+
+        Args:
+            speed: Animation speed (frames between updates).
+            wave_width: Width of shimmer wave in characters.
+        """
+        self.speed = speed
+        self.wave_width = wave_width
+        self.frame_counter = 0
+        self.position = 0
+
+    def configure(self, speed: int, wave_width: int) -> None:
+        """Configure shimmer parameters.
+
+        Args:
+            speed: Animation speed.
+            wave_width: Wave width.
+        """
+        self.speed = speed
+        self.wave_width = wave_width
+
+    def apply_shimmer(self, text: str) -> str:
+        """Apply elegant wave shimmer effect to text.
+
+        Args:
+            text: Text to apply shimmer to.
+
+        Returns:
+            Text with shimmer effect applied.
+        """
+        if not text:
+            return text
+
+        # Update shimmer position
+        self.frame_counter = (self.frame_counter + 1) % self.speed
+        if self.frame_counter == 0:
+            self.position = (self.position + 1) % (len(text) + self.wave_width * 2)
+
+        result = []
+        for i, char in enumerate(text):
+            distance = abs(i - self.position)
+
+            if distance == 0:
+                # Center - bright cyan
+                result.append(
+                    f"{ColorPalette.BRIGHT_CYAN}{char}{ColorPalette.RESET}"
+                )
+            elif distance == 1:
+                # Adjacent - bright blue
+                result.append(
+                    f"{ColorPalette.BRIGHT_BLUE}{char}{ColorPalette.RESET}"
+                )
+            elif distance == 2:
+                # Second ring - normal blue
+                result.append(
+                    f"{ColorPalette.NORMAL_BLUE}{char}{ColorPalette.RESET}"
+                )
+            elif distance <= self.wave_width:
+                # Edge - dim blue
+                result.append(f"{ColorPalette.DIM_BLUE}{char}{ColorPalette.RESET}")
+            else:
+                # Base - darker dim blue
+                result.append(f"\033[2;94m{char}{ColorPalette.RESET}")
+
+        return "".join(result)
+
+
+class PulseEffect:
+    """Handles pulsing brightness animation effects."""
+
+    def __init__(self, speed: int = 3, pulse_width: int = 2):
+        """Initialize pulse effect.
+
+        Args:
+            speed: Animation speed (frames between updates).
+            pulse_width: Number of brightness levels in pulse.
+        """
+        self.speed = speed
+        self.pulse_width = pulse_width
+        self.frame_counter = 0
+        self.brightness_level = 0
+        self.direction = 1  # 1 for getting brighter, -1 for getting dimmer
+
+    def configure(self, speed: int, pulse_width: int) -> None:
+        """Configure pulse parameters.
+
+        Args:
+            speed: Animation speed.
+            pulse_width: Pulse width.
+        """
+        self.speed = speed
+        self.pulse_width = pulse_width
+
+    def apply_pulse(self, text: str) -> str:
+        """Apply pulsing brightness effect to text.
+
+        Args:
+            text: Text to apply pulse to.
+
+        Returns:
+            Text with pulse effect applied.
+        """
+        if not text:
+            return text
+
+        # Update pulse brightness
+        self.frame_counter = (self.frame_counter + 1) % self.speed
+        if self.frame_counter == 0:
+            # Move brightness level
+            self.brightness_level += self.direction
+
+            # Reverse direction at bounds
+            if self.brightness_level >= self.pulse_width:
+                self.direction = -1
+                self.brightness_level = self.pulse_width
+            elif self.brightness_level <= 0:
+                self.direction = 1
+                self.brightness_level = 0
+
+        # Determine color based on brightness level
+        if self.brightness_level == self.pulse_width:
+            # Peak brightness - bright yellow
+            color = ColorPalette.BRIGHT_YELLOW
+        elif self.brightness_level >= self.pulse_width * 2 // 3:
+            # Bright - yellow
+            color = ColorPalette.YELLOW
+        elif self.brightness_level >= self.pulse_width // 3:
+            # Medium - dim yellow
+            color = ColorPalette.DIM_YELLOW
+        else:
+            # Dim - dim grey
+            color = ColorPalette.DIM_GREY
+
+        result = []
+        for char in text:
+            result.append(f"{color}{char}{ColorPalette.RESET}")
+
+        return "".join(result)
+
+
+class ScrambleEffect:
+    """Handles text scramble shimmer animation effects."""
+
+    # Special characters for scramble effect (matrix-style)
+    SCRAMBLE_CHARS = "!@#$%^&*()_+-=[]{}|;:,.<>?/~`0123456789abcdefghijklmnopqrstuvwxyz"
+
+    def __init__(self, speed: int = 2, window_size: int = 6):
+        """Initialize scramble effect.
+
+        Args:
+            speed: Animation speed (frames between updates).
+            window_size: Size of scrambling window in characters.
+        """
+        self.speed = speed
+        self.window_size = window_size
+        self.frame_counter = 0
+        self.position = 0
+
+    def configure(self, speed: int, window_size: int) -> None:
+        """Configure scramble parameters.
+
+        Args:
+            speed: Animation speed.
+            window_size: Scramble window size.
+        """
+        self.speed = speed
+        self.window_size = window_size
+
+    def _get_scramble_char(self, index: int) -> str:
+        """Get a random scramble character.
+
+        Args:
+            index: Character position for deterministic randomness.
+
+        Returns:
+            Random scramble character.
+        """
+        import random
+        # Use index + frame for more chaotic scrambling
+        random.seed(index + self.position + self.frame_counter)
+        return random.choice(self.SCRAMBLE_CHARS)
+
+    def apply_scramble(self, text: str) -> str:
+        """Apply text scramble shimmer effect.
+
+        Creates a moving window of scrambled characters that flows
+        through the text like a shimmer.
+
+        Args:
+            text: Text to apply effect to.
+
+        Returns:
+            Text with scramble shimmer effect applied.
+        """
+        if not text:
+            return text
+
+        # Update position like shimmer
+        self.frame_counter = (self.frame_counter + 1) % self.speed
+        if self.frame_counter == 0:
+            self.position = (self.position + 1) % (len(text) + self.window_size * 2)
+
+        result = []
+        for i, char in enumerate(text):
+            distance = abs(i - self.position)
+
+            if distance < self.window_size:
+                # Inside scramble window - show random character
+                scramble = self._get_scramble_char(i)
+                # More chaotic at center of window
+                if distance == 0:
+                    # Center - bright cyan
+                    result.append(
+                        f"{ColorPalette.BRIGHT_CYAN}{scramble}{ColorPalette.RESET}"
+                    )
+                elif distance < self.window_size // 2:
+                    # Near center - cyan
+                    result.append(
+                        f"{ColorPalette.CYAN}{scramble}{ColorPalette.RESET}"
+                    )
+                else:
+                    # Edge - dim cyan
+                    result.append(
+                        f"{ColorPalette.DIM_CYAN}{scramble}{ColorPalette.RESET}"
+                    )
+            else:
+                # Outside window - show actual character with green color
+                result.append(
+                    f"{ColorPalette.BRIGHT_GREEN}{char}{ColorPalette.RESET}"
+                )
+
+        return "".join(result)
+
+
+class AgnosterSegment:
+    """Builder for powerline/agnoster style segments."""
+
+    def __init__(self):
+        """Initialize empty segment list."""
+        self.segments: List[Tuple[Tuple[int, int, int], Tuple[int, int, int], str]] = []
+
+    def add(
+        self,
+        text: str,
+        bg: Tuple[int, int, int],
+        fg: Tuple[int, int, int] = AgnosterColors.TEXT_DARK
+    ) -> "AgnosterSegment":
+        """Add a segment.
+
+        Args:
+            text: Segment text content.
+            bg: Background color RGB tuple.
+            fg: Foreground (text) color RGB tuple.
+
+        Returns:
+            Self for chaining.
+        """
+        self.segments.append((bg, fg, text))
+        return self
+
+    def add_lime(self, text: str, variant: str = "normal") -> "AgnosterSegment":
+        """Add a lime-colored segment.
+
+        Args:
+            text: Segment text.
+            variant: "normal", "dark", or "darker".
+
+        Returns:
+            Self for chaining.
+        """
+        bg_map = {
+            "normal": AgnosterColors.LIME,
+            "dark": AgnosterColors.LIME_DARK,
+            "darker": AgnosterColors.LIME_DARKER,
+        }
+        return self.add(text, bg_map.get(variant, AgnosterColors.LIME))
+
+    def add_cyan(self, text: str, variant: str = "normal") -> "AgnosterSegment":
+        """Add a cyan-colored segment.
+
+        Args:
+            text: Segment text.
+            variant: "normal", "dark", or "light".
+
+        Returns:
+            Self for chaining.
+        """
+        bg_map = {
+            "normal": AgnosterColors.CYAN,
+            "dark": AgnosterColors.CYAN_DARK,
+            "light": AgnosterColors.CYAN_LIGHT,
+        }
+        return self.add(text, bg_map.get(variant, AgnosterColors.CYAN))
+
+    def add_neutral(self, text: str, variant: str = "mid") -> "AgnosterSegment":
+        """Add a neutral gray segment.
+
+        Args:
+            text: Segment text.
+            variant: "dark", "mid", or "light".
+
+        Returns:
+            Self for chaining.
+        """
+        bg_map = {
+            "dark": AgnosterColors.BG_DARK,
+            "mid": AgnosterColors.BG_MID,
+            "light": AgnosterColors.BG_LIGHT,
+        }
+        fg = AgnosterColors.TEXT_LIGHT
+        return self.add(text, bg_map.get(variant, AgnosterColors.BG_MID), fg)
+
+    def render(self, separator: str = Powerline.RIGHT) -> str:
+        """Render all segments with powerline separators.
+
+        Args:
+            separator: Powerline separator character to use.
+
+        Returns:
+            Fully formatted powerline string.
+        """
+        if not self.segments:
+            return ""
+
+        result = []
+        reset = ColorPalette.RESET
+
+        for i, (bg, fg, text) in enumerate(self.segments):
+            bg_code = make_bg_color(*bg)
+            fg_code = make_fg_color(*fg)
+
+            # Segment content with padding
+            result.append(f"{bg_code}{fg_code} {text} ")
+
+            # Add separator (arrow colored: fg=current_bg, bg=next_bg or transparent)
+            if i < len(self.segments) - 1:
+                next_bg = self.segments[i + 1][0]
+                sep_fg = make_fg_color(*bg)  # Arrow color = current segment bg
+                sep_bg = make_bg_color(*next_bg)  # Arrow bg = next segment bg
+                result.append(f"{sep_bg}{sep_fg}{separator}")
+            else:
+                # Last segment - arrow fades to transparent
+                sep_fg = make_fg_color(*bg)
+                result.append(f"{reset}{sep_fg}{separator}{reset}")
+
+        return "".join(result)
+
+    def render_minimal(self) -> str:
+        """Render segments with thin separators (less prominent).
+
+        Returns:
+            Formatted string with thin separators.
+        """
+        return self.render(Powerline.RIGHT_THIN)
+
+
 class GradientRenderer:
     """Handles various gradient effects."""
 
@@ -203,6 +880,9 @@ class GradientRenderer:
     def apply_dim_scheme_gradient(text: str) -> str:
         """Apply ultra-smooth gradient using dim color scheme.
 
+        Automatically uses 256-color fallback when true color
+        is not supported by the terminal.
+
         Args:
             text: Text to apply gradient to.
 
@@ -215,6 +895,7 @@ class GradientRenderer:
         result = []
         text_length = len(text)
         color_rgb = ColorPalette.DIM_SCHEME_COLORS
+        use_true_color = get_color_support() == ColorSupport.TRUE_COLOR
 
         for i, char in enumerate(text):
             position = i / max(1, text_length - 1)
@@ -233,7 +914,14 @@ class GradientRenderer:
                 b = curr_rgb[2] + (next_rgb[2] - curr_rgb[2]) * t
 
             r, g, b = int(r), int(g), int(b)
-            color_code = f"\033[38;2;{r};{g};{b}m"
+
+            if use_true_color:
+                color_code = f"\033[38;2;{r};{g};{b}m"
+            else:
+                # Fallback to 256-color palette
+                color_idx = rgb_to_256(r, g, b)
+                color_code = f"\033[38;5;{color_idx}m"
+
             result.append(f"{color_code}{char}")
 
         result.append(ColorPalette.RESET)
@@ -243,6 +931,9 @@ class GradientRenderer:
     def apply_custom_gradient(text: str, colors: List[Tuple[int, int, int]]) -> str:
         """Apply custom RGB gradient to text.
 
+        Automatically uses 256-color fallback when true color
+        is not supported by the terminal.
+
         Args:
             text: Text to apply gradient to.
             colors: List of RGB color tuples for gradient stops.
@@ -255,6 +946,7 @@ class GradientRenderer:
 
         result = []
         text_length = len(text)
+        use_true_color = get_color_support() == ColorSupport.TRUE_COLOR
 
         for i, char in enumerate(text):
             position = i / max(1, text_length - 1)
@@ -273,81 +965,17 @@ class GradientRenderer:
                 b = curr_rgb[2] + (next_rgb[2] - curr_rgb[2]) * t
 
             r, g, b = int(r), int(g), int(b)
-            color_code = f"\033[38;2;{r};{g};{b}m"
-            result.append(f"{color_code}{char}")
 
-        result.append(ColorPalette.RESET)
-        return "".join(result)
-
-
-class ShimmerEffect:
-    """Handles shimmer animation effects."""
-
-    def __init__(self, speed: int = 3, wave_width: int = 4):
-        """Initialize shimmer effect.
-
-        Args:
-            speed: Animation speed (frames between updates).
-            wave_width: Width of shimmer wave in characters.
-        """
-        self.speed = speed
-        self.wave_width = wave_width
-        self.frame_counter = 0
-        self.position = 0
-
-    def configure(self, speed: int, wave_width: int) -> None:
-        """Configure shimmer parameters.
-
-        Args:
-            speed: Animation speed.
-            wave_width: Wave width.
-        """
-        self.speed = speed
-        self.wave_width = wave_width
-
-    def apply_shimmer(self, text: str) -> str:
-        """Apply elegant wave shimmer effect to text.
-
-        Args:
-            text: Text to apply shimmer to.
-
-        Returns:
-            Text with shimmer effect applied.
-        """
-        if not text:
-            return text
-
-        # Update shimmer position
-        self.frame_counter = (self.frame_counter + 1) % self.speed
-        if self.frame_counter == 0:
-            self.position = (self.position + 1) % (len(text) + self.wave_width * 2)
-
-        result = []
-        for i, char in enumerate(text):
-            distance = abs(i - self.position)
-
-            if distance == 0:
-                # Center - bright cyan
-                result.append(
-                    f"{ColorPalette.BRIGHT_CYAN}{char}{ColorPalette.RESET}"
-                )
-            elif distance == 1:
-                # Adjacent - bright blue
-                result.append(
-                    f"{ColorPalette.BRIGHT_BLUE}{char}{ColorPalette.RESET}"
-                )
-            elif distance == 2:
-                # Second ring - normal blue
-                result.append(
-                    f"{ColorPalette.NORMAL_BLUE}{char}{ColorPalette.RESET}"
-                )
-            elif distance <= self.wave_width:
-                # Edge - dim blue
-                result.append(f"{ColorPalette.DIM_BLUE}{char}{ColorPalette.RESET}")
+            if use_true_color:
+                color_code = f"\033[38;2;{r};{g};{b}m"
             else:
-                # Base - darker dim blue
-                result.append(f"\033[2;94m{char}{ColorPalette.RESET}")
+                # Fallback to 256-color palette
+                color_idx = rgb_to_256(r, g, b)
+                color_code = f"\033[38;5;{color_idx}m"
+
+            result.append(f"{color_code}{char}")
 
+        result.append(ColorPalette.RESET)
         return "".join(result)
 
 
@@ -569,13 +1197,30 @@ class BannerRenderer:
         "\r ▀  ▀ ▀▀▀▀ ▀▀▀ ▀▀▀ ▀  ▀ ▀▀▀  ▀▀▀▀ ▀ ▀▀ ▀ ▀  ▀ ▀▀▀  ",
         "\r ──────────────────────────────────────────────── ",
     ]
-    KOLLABOR_ASCII = [
+    KOLLABOR_ASCII2 = [
         "\r  ██╗  ██╔════════════════════════════════════════════╗",
         "\r  ██║ ██╔╝                                            ║",
         "\r  █████╔╝ █▀▀█ █   █   █▀▀█ █▀▀▄ █▀▀█ █▀▀█   █▀▀█ ▀█▀ ║",
         "\r  ██╔═██╗ █  █ █   █   █▄▄█ █▀▀▄ █  █ █▄▄▀   █▄▄█  █  ║",
         "\r  ██║  ██╗▀▀▀▀ ▀▀▀ ▀▀▀ ▀  ▀ ▀▀▀  ▀▀▀▀ ▀ ▀▀ ▀ ▀  ▀ ▀▀▀ ║",
         "\r  ╚═╝  ╚═╩════════════════════════════════════════════╝",
+    ] 
+    KOLLABOR_ASCII3 = [
+        "\r ┌──────────────────────────────────────────────────┐",
+        "\r │ ▄█─●─●─█▄  █ ▄▀ █▀▀█ █   █   █▀▀█ █▀▀▄ █▀▀█ █▀▀█ │",
+        "\r │ ██ │ │ ██  █▀▄  █  █ █   █   █▄▄█ █▀▀▄ █  █ █▄▄▀ │",
+        "\r │ ●──███──●  ▀  ▀ ▀▀▀▀ ▀▀▀ ▀▀▀ ▀  ▀ ▀▀▀  ▀▀▀▀ ▀ ▀▀ │",
+        "\r │ ██ │ │ ██      Collaborative Intelligence        │",
+        "\r │ ▀█─●─●─█▀                                        │",
+        "\r └──────────────────────────────────────────────────┘",
+    ]
+    
+    KOLLABOR_ASCII = [
+        "\r ╭──────────────────────────────────────────────────╮",
+        "\r │ ▄█─●─●─█▄  █ ▄▀ █▀▀█ █   █   █▀▀█ █▀▀▄ █▀▀█ █▀▀█ │",
+        "\r │ ●──███──●  █▀▄  █  █ █   █   █▄▄█ █▀▀▄ █  █ █▄▄▀ │",
+        "\r │ ▀█─●─●─█▀  █  █ █▄▄█ █▄▄ █▄▄ █  █ █▄▄▀ █▄▄█ █ █▄ │",
+        "\r ╰──────────────────────────────────────────────────╯",
     ]
 
     @classmethod
@@ -608,6 +1253,8 @@ class VisualEffects:
         """Initialize visual effects system."""
         self.gradient_renderer = GradientRenderer()
         self.shimmer_effect = ShimmerEffect()
+        self.pulse_effect = PulseEffect()
+        self.scramble_effect = ScrambleEffect()
         self.status_colorizer = StatusColorizer()
         self.banner_renderer = BannerRenderer()
 
@@ -643,7 +1290,7 @@ class VisualEffects:
 
         Args:
             text: Text to apply effect to.
-            effect_type: Type of effect ("shimmer", "dim", "normal").
+            effect_type: Type of effect ("shimmer", "pulse", "scramble", "dim", "none").
 
         Returns:
             Text with thinking effect applied.
@@ -654,9 +1301,13 @@ class VisualEffects:
 
         if effect_type == "shimmer":
             return self.shimmer_effect.apply_shimmer(text)
+        elif effect_type == "pulse":
+            return self.pulse_effect.apply_pulse(text)
+        elif effect_type == "scramble":
+            return self.scramble_effect.apply_scramble(text)
         elif effect_type == "dim":
             return f"{ColorPalette.DIM}{text}{ColorPalette.RESET}"
-        else:
+        else:  # none or normal
             return text
 
     def apply_message_gradient(