feat(viz): real terminal visualizations — sparklines, gauges, heatmaps, depth/CVD

Implements the Vision MVP visual layer on keyless data. New primitives in
tui/render/sparkline.py: heat_cell / heat_row (2D-heatmap intensity) and gauge
(min..max marker track), joining the existing sparkline / heat_bar /
diverging_bar / stacked_bar / histogram. The Command Center now renders them live:
- Regime: price sparkline + volatility gauge + a watchlist of per-coin price
  sparklines with % change (the "Price Action / Sparklines" MVP feature).
- Correlation: colored block-intensity heatmap (green +, red -, intensity = |r|).
- Funding/Flow: funding heatmap strip across symbols + open-interest depth bars.
Pure renderers unit-tested (tests/test_render_sparkline.py); the Command Center
smoke test asserts the glyphs render. Gate green (309 files).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: GroverChorizo

tests/test_render_sparkline.py

@@ -0,0 +1,47 @@
+"""Deterministic tests for terminal-viz primitives (tui/render/sparkline.py)."""
+
+from __future__ import annotations
+
+from tui.render import sparkline as sp
+
+
+def test_sparkline_low_to_high():
+    line = sp.sparkline([1, 2, 3, 4, 5, 6, 7, 8])
+    assert line[0] == "▁" and line[-1] == "█"
+
+
+def test_sparkline_constant_is_flat():
+    assert set(sp.sparkline([5, 5, 5])) == {"▁"}
+
+
+def test_sparkline_empty():
+    assert sp.sparkline([]) == ""
+
+
+def test_heat_bar_half():
+    bar = sp.heat_bar(5, 10, width=10)
+    assert bar.count("█") == 5 and bar.count("░") == 5
+
+
+def test_heat_cell_scale():
+    assert sp.heat_cell(0, 10) in {" ", "·"}
+    assert sp.heat_cell(10, 10) == "█"
+
+
+def test_heat_row_length():
+    row = sp.heat_row([1, 2, 3, 4], max_abs=4)
+    assert len(row) == 4 and row[-1] == "█"
+
+
+def test_gauge_marker_position():
+    assert sp.gauge(0, 0, 10, width=11)[0] == "●"      # low end
+    assert sp.gauge(10, 0, 10, width=11)[-1] == "●"     # high end
+    assert sp.gauge(5, 0, 10, width=11)[5] == "●"       # middle
+
+
+def test_diverging_bar_sign():
+    pos = sp.diverging_bar(1, 1, width=11)
+    neg = sp.diverging_bar(-1, 1, width=11)
+    # positive fills to the right of the centre marker, negative to the left
+    assert pos.index("│") < pos.rindex("█")
+    assert neg.index("█") < neg.index("│")

tests/ui/test_command_center.py

@@ -103,6 +103,11 @@ def after(app):
         seen["flow"] = _text(app.screen._flow.renderable)
 
     _run(CommandCenterScreen(), after)
-    assert "Trend" in seen["regime"]
+    # regime stats + watchlist + a rendered price sparkline
+    assert "Trend" in seen["regime"] and "Watchlist" in seen["regime"]
+    assert any(ch in seen["regime"] for ch in "▁▂▃▄▅▆▇█")
+    # correlation rendered as a heatmap (intensity glyphs), symbols labelled
     assert "BTC" in seen["corr"] and "ETH" in seen["corr"]
-    assert "Funding" in seen["flow"]
+    assert "█" in seen["corr"]
+    # funding heatmap strip present
+    assert "Funding" in seen["flow"] and "heatmap" in seen["flow"].lower()

tui/render/sparkline.py

@@ -73,3 +73,43 @@ def histogram(values: Iterable[float], *, width: int = 18) -> list[str]:
     series = [float(v or 0.0) for v in values]
     max_value = max(series) if series else 0.0
     return [heat_bar(v, max_value, width=width) for v in series]
+
+
+HEAT_CELLS = " ·░▒▓█"
+
+
+def heat_cell(value: float, max_abs: float) -> str:
+    """Map a magnitude to a single intensity glyph (for 2D heatmaps)."""
+    try:
+        v = abs(float(value))
+        m = abs(float(max_abs))
+    except (TypeError, ValueError):
+        return HEAT_CELLS[0]
+    if m <= 0:
+        return HEAT_CELLS[1]
+    idx = int(round(min(v / m, 1.0) * (len(HEAT_CELLS) - 1)))
+    return HEAT_CELLS[idx]
+
+
+def heat_row(values: Iterable[float], *, max_abs: float | None = None) -> str:
+    """A 1-D heatmap row of intensity glyphs (one per value)."""
+    series = [float(v) for v in values if v is not None]
+    if not series:
+        return ""
+    m = max_abs if max_abs is not None else max((abs(v) for v in series), default=0.0)
+    return "".join(heat_cell(v, m) for v in series)
+
+
+def gauge(value: float, low: float, high: float, *, width: int = 12) -> str:
+    """A min..max gauge track with a marker, e.g. ``──●───────`` for low-ish."""
+    if width <= 1:
+        return "●"
+    try:
+        v, lo, hi = float(value), float(low), float(high)
+    except (TypeError, ValueError):
+        v, lo, hi = 0.0, 0.0, 1.0
+    ratio = 0.5 if hi <= lo else min(max((v - lo) / (hi - lo), 0.0), 1.0)
+    pos = int(round(ratio * (width - 1)))
+    track = ["─"] * width
+    track[pos] = "●"
+    return "".join(track)

tui/ui/screens/command_center.py

@@ -23,6 +23,7 @@
 from textual.widgets import Static, TabbedContent, TabPane
 
 from tui import analytics
+from tui.render import sparkline as sp
 from tui.ui.screens.base import BaseScreen
 
 MAJORS = ["BTC", "ETH", "SOL", "BNB", "XRP", "DOGE"]
@@ -159,60 +160,96 @@ def _render(
         self._health.update(self._render_health(health or {}))
 
     def _render_regime(self, selected, closes, snapshot):
-        series = closes.get(selected) or next(iter(closes.values()), [])
-        sym = selected if closes.get(selected) else (
-            next(iter(closes), selected)
-        )
-        if not series:
+        if not closes:
             return Text("No candle data yet.", style="dim")
+        sym = selected if closes.get(selected) else next(iter(closes), selected)
+        series = closes.get(sym, [])
         r = analytics.regime(series)
         trend_color = {"up": "green", "down": "red", "flat": "yellow"}.get(
             r["trend"], "white"
         )
-        t = Table.grid(padding=(0, 2))
-        t.add_column(justify="right", style="bold")
-        t.add_column()
-        t.add_row("Symbol", sym)
-        t.add_row("Trend", Text(str(r["trend"]).upper(), style=trend_color))
-        t.add_row("Volatility", f"{r['vol_state']}  (pct {r['vol_pct']:.0%})")
-        t.add_row("Realized vol", f"{r['vol']:.4%}")
-        t.add_row("Drift vs SMA", f"{r.get('drift', 0.0):+.2%}")
-        return t
+        stats = Table.grid(padding=(0, 2))
+        stats.add_column(justify="right", style="bold")
+        stats.add_column()
+        stats.add_row("Symbol", sym)
+        stats.add_row("Price 48×1h", Text(sp.sparkline(series, width=48), style=trend_color))
+        stats.add_row("Trend", Text(str(r["trend"]).upper(), style=trend_color))
+        stats.add_row(
+            "Volatility",
+            f"{r['vol_state']:<7}{sp.gauge(r['vol_pct'], 0, 1, width=14)} {r['vol_pct']:.0%}",
+        )
+        stats.add_row("Realized vol", f"{r['vol']:.4%}")
+        stats.add_row("Drift vs SMA", Text(f"{r.get('drift', 0.0):+.2%}", style=trend_color))
+
+        # Watchlist: price sparkline per major (the MVP "Price Action" feature).
+        watch = Table(title="Watchlist · 48×1h", box=box.ASCII, expand=False)
+        watch.add_column("sym", style="bold")
+        watch.add_column("last", justify="right")
+        watch.add_column("chg", justify="right")
+        watch.add_column("spark")
+        for s in sorted(closes):
+            cs = closes[s]
+            chg = (cs[-1] - cs[0]) / cs[0] if cs and cs[0] else 0.0
+            col = "green" if chg >= 0 else "red"
+            watch.add_row(
+                s, f"{cs[-1]:,.6g}",
+                Text(f"{chg:+.2%}", style=col),
+                Text(sp.sparkline(cs, width=32), style=col),
+            )
+        grid = Table.grid(padding=(1, 0))
+        grid.add_row(stats)
+        grid.add_row(watch)
+        return grid
 
     def _render_correlation(self, closes):
         if len(closes) < 2:
             return Text("Need ≥2 symbols with candles for correlation.", style="dim")
         symbols, matrix = analytics.correlation_matrix(closes)
         table = Table(
-            title="1h return correlation",
-            show_lines=False,
-            expand=False,
-            box=box.ASCII,
+            title="1h return correlation · heatmap (green=+ red=- intensity=|r|)",
+            show_lines=False, expand=False, box=box.ASCII,
         )
         table.add_column("")
         for s in symbols:
-            table.add_column(s, justify="right")
+            table.add_column(s, justify="center")
         for i, a in enumerate(symbols):
             cells = [Text(a, style="bold")]
             for j, _ in enumerate(symbols):
                 v = matrix[i][j]
                 if v is None:
-                    cells.append(Text("·", style="dim"))
+                    cells.append(Text("  ", style="dim"))
                 else:
-                    style = "green" if v > 0.5 else "red" if v < -0.5 else "white"
-                    cells.append(Text(f"{v:+.2f}", style=style))
+                    color = "green" if v > 0 else "red" if v < 0 else "white"
+                    cells.append(Text(sp.heat_cell(v, 1.0) * 2, style=color))
             table.add_row(*cells)
         return table
 
     def _render_flow(self, snapshot):
         if not snapshot:
             return Text("No market snapshot yet.", style="dim")
-        ext = analytics.funding_extremes(snapshot, n=5)
-        oi = analytics.oi_leaders(snapshot, n=5)
-        table = Table.grid(padding=(0, 3))
-        table.add_column()
-        table.add_column()
-        table.add_column()
+        ext = analytics.funding_extremes(snapshot, n=6)
+        oi = analytics.oi_leaders(snapshot, n=6)
+        oi_max = max((v for _, v in oi), default=1.0)
+        out = Table.grid(padding=(1, 0))
+
+        # Funding heatmap strip across all symbols (intensity=|funding|, sign-colored).
+        fr: list[tuple[str, float]] = []
+        for r in snapshot:
+            try:
+                fr.append((str(r.get("symbol") or "?"), float(r.get("funding"))))
+            except (TypeError, ValueError):
+                continue
+        if fr:
+            fmax = max(abs(f) for _, f in fr) or 1.0
+            strip = Text("Funding heatmap  ", style="dim")
+            for _s, f in fr[:48]:
+                strip.append(sp.heat_cell(f, fmax), style="green" if f >= 0 else "red")
+            out.add_row(strip)
+
+        cols = Table.grid(padding=(0, 3))
+        cols.add_column()
+        cols.add_column()
+        cols.add_column()
 
         def col(title, pairs, fmt):
             inner = Table(title=title, show_edge=False, box=box.ASCII)
@@ -222,12 +259,13 @@ def col(title, pairs, fmt):
                 inner.add_row(sym, fmt(val))
             return inner
 
-        table.add_row(
+        cols.add_row(
             col("Funding +", ext["most_positive"], lambda v: Text(f"{v:+.4%}", style="green")),
             col("Funding -", ext["most_negative"], lambda v: Text(f"{v:+.4%}", style="red")),
-            col("Open interest", oi, lambda v: f"{v:,.0f}"),
+            col("Open interest", oi, lambda v: Text(f"{sp.heat_bar(v, oi_max, width=10)} {v:,.0f}")),
         )
-        return table
+        out.add_row(cols)
+        return out
 
     def _render_health(self, health):
         if not health: