Enhance user experience by clearing 'Waiting for approval' status immediately upon approval and refining markdown table styles for better readability and aesthetics.

agent/utils/boot_timing.py

@@ -0,0 +1,15 @@
+"""Shared timing and color helpers for startup visual effects."""
+
+import math
+
+
+def settle_curve(progress: float, sharpness: float = 3.0) -> float:
+    """Return noise amount in range 1..0 for normalized progress 0..1."""
+    t = max(0.0, min(1.0, progress))
+    return math.exp(-sharpness * t)
+
+
+def warm_gold_from_white(progress: float) -> tuple[int, int, int]:
+    """Interpolate from white to warm gold for progress 0..1."""
+    t = max(0.0, min(1.0, progress))
+    return 255, int(255 - 55 * t), int(255 - 175 * t)

agent/utils/crt_boot.py

@@ -0,0 +1,113 @@
+"""CRT / glitch boot sequence effect for CLI startup.
+
+Simulates an old CRT terminal booting up: text appearing character by character
+with noise artifacts, then settling into a clean display.
+"""
+
+import random
+import time
+
+from rich.console import Console
+from rich.text import Text
+from rich.live import Live
+
+from agent.utils.boot_timing import settle_curve
+
+
+def _glitch_text(text: str, intensity: float, rng: random.Random) -> str:
+    """Add random glitch characters to text."""
+    glitch_chars = "█▓▒░┃┫┣╋╏╎─━┅┄"
+    result = list(text)
+    for i in range(len(result)):
+        if rng.random() < intensity:
+            result[i] = rng.choice(glitch_chars)
+    return "".join(result)
+
+
+def run_boot_sequence(console: Console, boot_lines: list[tuple[str, str]]) -> None:
+    """Run the CRT boot sequence effect.
+
+    Args:
+        console: Rich console instance.
+        boot_lines: List of (text, rich_style) tuples to display.
+    """
+    term_height = min(console.height - 2, 40)
+    rng = random.Random(42)
+
+    with Live(console=console, refresh_per_second=30, transient=True) as live:
+        displayed_lines: list[tuple[str, str]] = []
+
+        for line_text, line_style in boot_lines:
+            if not line_text:
+                displayed_lines.append(("", ""))
+                continue
+
+            line_len = max(1, len(line_text))
+            # Type out each character
+            for char_idx in range(len(line_text) + 1):
+                result = Text()
+                progress = char_idx / line_len
+                noise = settle_curve(progress)
+                prev_glitch_chance = 0.01 + 0.06 * noise
+                prev_glitch_intensity = 0.02 + 0.12 * noise
+                scanline_chance = 0.005 + 0.03 * noise
+
+                # Render previously completed lines
+                for prev_text, prev_style in displayed_lines:
+                    if rng.random() < prev_glitch_chance:
+                        result.append(_glitch_text(prev_text, prev_glitch_intensity, rng), style=prev_style)
+                    else:
+                        result.append(prev_text, style=prev_style)
+                    result.append("\n")
+
+                # Current line being typed
+                typed = line_text[:char_idx]
+                cursor = "█" if char_idx < len(line_text) else ""
+
+                # Noise after cursor
+                noise_tail = ""
+                if char_idx < len(line_text):
+                    noise_len = rng.randint(0, int(1 + 5 * noise))
+                    noise_tail = "".join(rng.choice("░▒▓") for _ in range(noise_len))
+
+                result.append(typed, style=line_style)
+                result.append(cursor, style="bold rgb(255,200,80)")
+                result.append(noise_tail, style="dim rgb(180,140,40)")
+                result.append("\n")
+
+                # Faint scanlines in remaining space
+                remaining = term_height - len(displayed_lines) - 2
+                for _ in range(max(0, remaining)):
+                    if rng.random() < scanline_chance:
+                        scan_len = rng.randint(5, 30)
+                        result.append("─" * scan_len, style="dim rgb(180,140,40)")
+                    result.append("\n")
+
+                live.update(result)
+
+                # Variable typing speed
+                if line_text[char_idx - 1:char_idx] in " .":
+                    time.sleep(0.025)
+                else:
+                    time.sleep(0.010)
+
+            displayed_lines.append((line_text, line_style))
+            time.sleep(0.06)
+
+        # Hold with blinking cursor
+        for frame in range(20):
+            result = Text()
+            for prev_text, prev_style in displayed_lines:
+                result.append(prev_text, style=prev_style)
+                result.append("\n")
+            if frame % 8 < 4:
+                result.append("█", style="rgb(255,200,80)")
+            live.update(result)
+            time.sleep(0.05)
+
+    # Print final clean frame
+    final = Text()
+    for prev_text, prev_style in displayed_lines:
+        final.append(prev_text, style=prev_style)
+        final.append("\n")
+    console.print(final)

agent/utils/particle_logo.py

@@ -0,0 +1,228 @@
+"""Particle coalesce effect for the HUGGING FACE AGENT logo.
+
+Random particles swirl in from the edges, converge to form the text
+"HUGGING FACE AGENT", hold briefly, then the final frame is printed.
+Rendered with braille characters for high detail.
+
+Based on Leandro's particle_coalesce.py demo.
+"""
+
+import math
+import random
+import time
+
+from rich.console import Console
+from rich.text import Text
+from rich.align import Align
+from rich.live import Live
+
+from agent.utils.braille import BrailleCanvas, text_to_pixels
+from agent.utils.boot_timing import settle_curve, warm_gold_from_white
+
+
+class Particle:
+    __slots__ = ("x", "y", "target_x", "target_y", "vx", "vy", "phase", "delay")
+
+    def __init__(self, x: float, y: float, target_x: float, target_y: float, delay: float = 0):
+        self.x = x
+        self.y = y
+        self.target_x = target_x
+        self.target_y = target_y
+        self.vx = 0.0
+        self.vy = 0.0
+        self.phase = random.uniform(0, math.pi * 2)
+        self.delay = delay
+
+    def update_converge(self, t: float, strength: float = 0.08, damping: float = 0.92):
+        """Move toward target with spring-like physics."""
+        if t < self.delay:
+            # Still in swirl phase
+            self.x += self.vx
+            self.y += self.vy
+            self.vx *= 0.99
+            self.vy *= 0.99
+            # Gentle spiral
+            angle = self.phase + t * 2
+            self.vx += math.cos(angle) * 0.3
+            self.vy += math.sin(angle) * 0.3
+            return
+
+        # Spring toward target
+        dx = self.target_x - self.x
+        dy = self.target_y - self.y
+        self.vx += dx * strength
+        self.vy += dy * strength
+        self.vx *= damping
+        self.vy *= damping
+        self.x += self.vx
+        self.y += self.vy
+
+    @property
+    def at_target(self) -> bool:
+        return abs(self.x - self.target_x) < 1.5 and abs(self.y - self.target_y) < 1.5
+
+
+def run_particle_logo(console: Console, hold_seconds: float = 1.5) -> None:
+    """Run the particle coalesce effect."""
+    term_width = min(console.width, 120)
+    term_height = min(console.height - 4, 35)
+
+    canvas = BrailleCanvas(term_width, term_height)
+
+    # Get target positions from text
+    text_pixels_line1 = text_to_pixels("HUGGING FACE", scale=2)
+    text_pixels_line2 = text_to_pixels("AGENT", scale=2)
+
+    # Calculate dimensions for centering
+    def get_bounds(pixels):
+        if not pixels:
+            return 0, 0, 0, 0
+        xs = [p[0] for p in pixels]
+        ys = [p[1] for p in pixels]
+        return min(xs), max(xs), min(ys), max(ys)
+
+    min_x1, max_x1, min_y1, max_y1 = get_bounds(text_pixels_line1)
+    min_x2, max_x2, min_y2, max_y2 = get_bounds(text_pixels_line2)
+
+    w1, h1 = max_x1 - min_x1 + 1, max_y1 - min_y1 + 1
+    w2, h2 = max_x2 - min_x2 + 1, max_y2 - min_y2 + 1
+
+    total_h = h1 + 6 + h2  # gap between lines
+    start_y = (canvas.pixel_height - total_h) // 2
+
+    # Center line 1
+    offset_x1 = (canvas.pixel_width - w1) // 2 - min_x1
+    offset_y1 = start_y - min_y1
+    targets_1 = [(p[0] + offset_x1, p[1] + offset_y1) for p in text_pixels_line1]
+
+    # Center line 2
+    offset_x2 = (canvas.pixel_width - w2) // 2 - min_x2
+    offset_y2 = start_y + h1 + 6 - min_y2
+    targets_2 = [(p[0] + offset_x2, p[1] + offset_y2) for p in text_pixels_line2]
+
+    all_targets = targets_1 + targets_2
+
+    # Subsample for performance — take every Nth pixel
+    step = max(1, len(all_targets) // 1500)
+    sampled_targets = all_targets[::step]
+
+    # Create particles at random edge positions
+    rng = random.Random(42)
+    particles = []
+    pw, ph = canvas.pixel_width, canvas.pixel_height
+
+    for i, (tx, ty) in enumerate(sampled_targets):
+        # Spawn from random edge
+        side = rng.choice(["top", "bottom", "left", "right"])
+        if side == "top":
+            sx, sy = rng.uniform(0, pw), rng.uniform(-20, -5)
+        elif side == "bottom":
+            sx, sy = rng.uniform(0, pw), rng.uniform(ph + 5, ph + 20)
+        elif side == "left":
+            sx, sy = rng.uniform(-20, -5), rng.uniform(0, ph)
+        else:
+            sx, sy = rng.uniform(pw + 5, pw + 20), rng.uniform(0, ph)
+
+        delay = rng.uniform(0, 0.4)  # staggered start
+        p = Particle(sx, sy, tx, ty, delay=delay)
+        # Initial velocity — gentle swirl
+        angle = math.atan2(ph / 2 - sy, pw / 2 - sx) + rng.gauss(0, 0.8)
+        speed = rng.uniform(1.0, 2.5)
+        p.vx = math.cos(angle) * speed
+        p.vy = math.sin(angle) * speed
+        particles.append(p)
+
+    # Also add some extra ambient particles that never converge
+    ambient = []
+    for _ in range(200):
+        ax = rng.uniform(0, pw)
+        ay = rng.uniform(0, ph)
+        ap = Particle(ax, ay, ax, ay)
+        ap.vx = rng.gauss(0, 1)
+        ap.vy = rng.gauss(0, 1)
+        ambient.append(ap)
+
+    # Timing: 1s converge + 2s hold = 3s total
+    fps = 24
+    converge_frames = int(fps * 0.9)
+    hold_frames = int(fps * hold_seconds)
+    total_frames = converge_frames + hold_frames
+
+    with Live(console=console, refresh_per_second=fps, transient=True) as live:
+        for frame in range(total_frames):
+            canvas.clear()
+            t = frame * 0.03
+
+            # Update ambient particles (always drifting)
+            for ap in ambient:
+                ap.x += ap.vx + math.sin(t + ap.phase) * 0.5
+                ap.y += ap.vy + math.cos(t + ap.phase * 1.3) * 0.5
+                # Wrap around
+                ap.x = ap.x % pw
+                ap.y = ap.y % ph
+
+                # Fade out ambient during hold phase
+                if frame < converge_frames:
+                    alpha = 0.3 + 0.2 * math.sin(t * 2 + ap.phase)
+                else:
+                    fade = (frame - converge_frames) / hold_frames
+                    alpha = (0.3 + 0.2 * math.sin(t * 2 + ap.phase)) * (1 - fade)
+                if alpha > 0.25:
+                    canvas.set_pixel(int(ap.x), int(ap.y))
+
+            if frame < converge_frames:
+                # Converge phase
+                progress = frame / converge_frames
+                noise = settle_curve(progress)
+                for p in particles:
+                    p.update_converge(t, strength=0.06, damping=0.90)
+                    canvas.set_pixel(int(p.x), int(p.y))
+
+                    # Trail effect
+                    trail_scale = 0.2 + 0.5 * noise
+                    trail_x = int(p.x - p.vx * trail_scale)
+                    trail_y = int(p.y - p.vy * trail_scale)
+                    canvas.set_pixel(trail_x, trail_y)
+
+                # Color transitions from white to warm gold
+                r, g, b = warm_gold_from_white(progress)
+            else:
+                # Hold phase — settle into solid logo
+                settle_t = (frame - converge_frames) / hold_frames
+                for p in particles:
+                    # Jitter decays to zero
+                    jitter = (1 - settle_t) * 0.7
+                    jx = p.target_x + math.sin(t * 3 + p.phase) * jitter
+                    jy = p.target_y + math.cos(t * 3 + p.phase * 1.5) * jitter
+                    canvas.set_pixel(int(jx), int(jy))
+                    canvas.set_pixel(int(p.target_x), int(p.target_y))
+
+                r, g, b = 255, 200, 80
+
+            # Render with color
+            lines = canvas.render()
+            result = Text()
+            for line in lines:
+                for ch in line:
+                    if ch == chr(0x2800):
+                        result.append(ch)
+                    else:
+                        result.append(ch, style=f"rgb({r},{g},{b})")
+                result.append("\n")
+
+            live.update(Align.center(result))
+            time.sleep(1.0 / fps)
+
+    # Print final settled frame
+    canvas.clear()
+    for p in particles:
+        canvas.set_pixel(int(p.target_x), int(p.target_y))
+    final = Text()
+    for line in canvas.render():
+        for ch in line:
+            if ch == chr(0x2800):
+                final.append(ch)
+            else:
+                final.append(ch, style="rgb(255,200,80)")
+        final.append("\n")
+    console.print(Align.center(final))