psystack 0.1.0__py3-none-any.whl

psystack/tui/widgets/signal_timeline.py

@@ -0,0 +1,206 @@
+"""Signal timeline — character-based sparkline with event markers."""
+
+from __future__ import annotations
+
+from enum import Enum
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.reactive import reactive, var
+from textual.widgets import Static
+
+from psystack.models.event import Event
+
+# Unicode block sparkline characters (proper visual bars)
+_SPARK_CHARS = " ▁▂▃▄▅▆▇█"
+
+
+class TimelineMode(str, Enum):
+    """Display modes for the signal timeline."""
+
+    DIVERGENCE = "divergence"
+    SIGNAL_COMPARE = "signal_compare"
+
+
+def _sparkline(values: list[float], width: int) -> str:
+    """Render a sparkline from values into a fixed-width string."""
+    if not values:
+        return " " * width
+
+    mn = min(values)
+    mx = max(values)
+    rng = mx - mn if mx != mn else 1.0
+
+    # Downsample or upsample to fit width
+    result = []
+    for i in range(width):
+        idx = int(i * len(values) / width)
+        idx = min(idx, len(values) - 1)
+        normalized = (values[idx] - mn) / rng
+        char_idx = int(normalized * (len(_SPARK_CHARS) - 1))
+        result.append(_SPARK_CHARS[char_idx])
+    return "".join(result)
+
+
+def _event_markers(events: list[Event], max_step: int, width: int) -> str:
+    """Render event position markers aligned to sparkline width."""
+    if not events or max_step == 0:
+        return "─" * width
+    chars = ["─"] * width
+    for evt in events:
+        pos = int(evt.step * width / max_step)
+        pos = min(pos, width - 1)
+        if evt.severity == "critical":
+            chars[pos] = "●"
+        elif evt.severity == "warning":
+            chars[pos] = "◆"
+        else:
+            chars[pos] = "·"
+    return "".join(chars)
+
+
+class SignalTimeline(Vertical):
+    """Character-based timeline showing divergence score over time."""
+
+    current_step: reactive[int] = reactive(0)
+    timeline_mode: var[TimelineMode] = var(TimelineMode.DIVERGENCE)
+
+    DEFAULT_CSS = """
+    SignalTimeline {
+        height: auto;
+        max-height: 10;
+        border: round $panel;
+        padding: 1 2;
+    }
+    SignalTimeline .st-sparkline {
+        color: $accent;
+    }
+    SignalTimeline .st-events {
+        color: $error;
+    }
+    SignalTimeline .st-cursor {
+        color: $warning;
+    }
+    """
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._scores: list[float] = []
+        self._events: list[Event] = []
+        self._max_step: int = 0
+        self._active_signal_name: str = ""
+        self._values_a: list[float] = []
+        self._values_b: list[float] = []
+        self._window_range: tuple[int, int] | None = None
+
+    def compose(self) -> ComposeResult:
+        self.border_title = "Timeline"
+        yield Static("", id="st-spark-a", classes="st-sparkline")
+        yield Static("", id="st-spark-b", classes="st-sparkline")
+        yield Static("", id="st-event-markers", classes="st-events")
+        yield Static("", id="st-cursor-line", classes="st-cursor")
+
+    def set_data(
+        self,
+        scores: list[float],
+        events: list[Event],
+        max_step: int,
+        values_a: list[float] | None = None,
+        values_b: list[float] | None = None,
+        active_signal_name: str = "",
+        window_range: tuple[int, int] | None = None,
+    ) -> None:
+        self._scores = scores
+        self._events = events
+        self._max_step = max_step
+        self._values_a = values_a or []
+        self._values_b = values_b or []
+        self._active_signal_name = active_signal_name
+        self._window_range = window_range
+        self._refresh_display()
+
+    def cycle_mode(self) -> None:
+        """Toggle between divergence and signal_compare modes."""
+        if self.timeline_mode == TimelineMode.DIVERGENCE:
+            self.timeline_mode = TimelineMode.SIGNAL_COMPARE
+        else:
+            self.timeline_mode = TimelineMode.DIVERGENCE
+
+    def watch_timeline_mode(self, value: TimelineMode) -> None:
+        self._refresh_display()
+
+    def watch_current_step(self, step: int) -> None:
+        self._render_cursor(step)
+
+    def _refresh_display(self) -> None:
+        width = max(self.size.width - 4, 20) if self.size.width > 0 else 60
+
+        # Update border title with mode label
+        spark_a = self.query_one("#st-spark-a", Static)
+        spark_b = self.query_one("#st-spark-b", Static)
+
+        if self.timeline_mode == TimelineMode.DIVERGENCE:
+            # Single sparkline from divergence scores
+            title_parts = ["Timeline"]
+            title_parts.append("[divergence]")
+            if self._active_signal_name:
+                title_parts.append(self._active_signal_name)
+            if self._window_range:
+                lo, hi = self._window_range
+                title_parts.append(f"[{lo}..{hi}]")
+            self.border_title = " \u2014 ".join(title_parts)
+            spark_text = Text()
+            spark_text.append("S ", style="bold dim")
+            spark_text.append(_sparkline(self._scores, width), style="")
+            spark_a.update(spark_text)
+            spark_b.update("")
+        else:
+            # Dual sparklines A/B (signal_compare mode)
+            signal_label = self._active_signal_name or "signal"
+            title_parts = ["Timeline", f"[{signal_label}]"]
+            if self._window_range:
+                lo, hi = self._window_range
+                title_parts.append(f"[{lo}..{hi}]")
+            self.border_title = " \u2014 ".join(title_parts)
+            if self._values_a:
+                text_a = Text()
+                text_a.append("A ", style="bold dim")
+                text_a.append(_sparkline(self._values_a, width), style="")
+                spark_a.update(text_a)
+            else:
+                text_a = Text()
+                text_a.append("S ", style="bold dim")
+                text_a.append(_sparkline(self._scores, width), style="")
+                spark_a.update(text_a)
+            if self._values_b:
+                text_b = Text()
+                text_b.append("B ", style="bold dim")
+                text_b.append(_sparkline(self._values_b, width), style="")
+                spark_b.update(text_b)
+            else:
+                spark_b.update("")
+
+        # Event markers
+        markers = self.query_one("#st-event-markers", Static)
+        marker_text = Text()
+        marker_text.append("E ", style="bold dim")
+        marker_text.append(_event_markers(self._events, self._max_step, width), style="")
+        markers.update(marker_text)
+
+        self._render_cursor(self.current_step)
+
+    def _render_cursor(self, step: int) -> None:
+        width = max(self.size.width - 4, 20) if self.size.width > 0 else 60
+        cursor = self.query_one("#st-cursor-line", Static)
+        if self._max_step > 0:
+            pos = int(step * width / self._max_step)
+            pos = min(pos, width - 1)
+            line = "╌" * pos + "▼" + "╌" * (width - pos - 1)
+            cursor_text = Text()
+            cursor_text.append("  ", style="")
+            cursor_text.append(line, style="")
+            cursor_text.append(f" t={step}", style="bold")
+            cursor.update(cursor_text)
+        else:
+            cursor.update("")

psystack/tui/widgets/status_badge.py

@@ -0,0 +1,52 @@
+"""Status badge with color variants."""
+
+from __future__ import annotations
+
+from textual.widgets import Static
+
+VARIANT_CLASSES = {
+    "completed": "status-completed",
+    "running": "status-running",
+    "failed": "status-failed",
+    "skipped": "status-skipped",
+    "default": "status-default",
+}
+
+
+class StatusBadge(Static):
+    DEFAULT_CSS = """
+    StatusBadge {
+        padding: 0 1;
+        margin: 0 1;
+        min-width: 8;
+        text-align: center;
+    }
+    StatusBadge.status-completed {
+        background: $success;
+        color: $text;
+    }
+    StatusBadge.status-running {
+        background: $warning;
+        color: $text;
+    }
+    StatusBadge.status-failed {
+        background: $error;
+        color: $text;
+    }
+    StatusBadge.status-skipped {
+        color: $text-muted;
+    }
+    StatusBadge.status-default {
+        color: $text;
+    }
+    """
+
+    def __init__(self, label: str, variant: str = "default", **kwargs: object) -> None:
+        super().__init__(label, **kwargs)
+        self.set_variant(variant)
+
+    def set_variant(self, variant: str) -> None:
+        for cls in VARIANT_CLASSES.values():
+            self.remove_class(cls)
+        css_class = VARIANT_CLASSES.get(variant, "status-default")
+        self.add_class(css_class)

psystack/tui/widgets/step_inspector.py

@@ -0,0 +1,105 @@
+"""Step inspector — shows A/B values at the current step with delta highlighting."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.widgets import Static
+
+if TYPE_CHECKING:
+    from psystack.core.signal_schema import SignalSchema
+
+from psystack.models.event import Event
+
+
+class StepInspector(Vertical):
+    """Bottom-right panel showing per-step A/B signal values with delta highlighting."""
+
+    DEFAULT_CSS = """
+    StepInspector {
+        width: 100%;
+        height: 1fr;
+        border: round $panel;
+        padding: 1 1;
+    }
+    StepInspector .si-content {
+        color: $text-muted;
+    }
+    """
+
+    def __init__(self, **kwargs: object) -> None:
+        super().__init__(**kwargs)
+        self._schema: SignalSchema | None = None
+
+    def compose(self) -> ComposeResult:
+        self.border_title = "Step Inspector"
+        yield Static("Select a step to inspect", id="si-content", classes="si-content")
+
+    def set_schema(self, schema: "SignalSchema | None") -> None:
+        self._schema = schema
+
+    def update_step(
+        self,
+        step: int,
+        signals_a: dict[str, float] | None = None,
+        signals_b: dict[str, float] | None = None,
+        event: Event | None = None,
+        hypothesis: str | None = None,
+    ) -> None:
+        content = self.query_one("#si-content", Static)
+        text = Text()
+        text.append(f"step {step}", style="bold")
+        text.append("\n")
+
+        # Show event info first if present (most important context)
+        if event:
+            text.append(event.type.replace("_", " "), style="")
+            text.append(f"  score={event.score:.3f}\n", style="dim")
+
+        # Signal deltas with directional arrows
+        if signals_a and signals_b:
+            keys: list[str] = []
+            if self._schema:
+                for group_name in self._schema.group_order:
+                    for sig_def in self._schema.groups.get(group_name, []):
+                        keys.append(sig_def.name)
+                schema_keys = set(self._schema.signal_names())
+                extra = sorted(set(signals_a.keys()) | set(signals_b.keys()) - schema_keys)
+                keys.extend(extra)
+            else:
+                keys = sorted(set(signals_a) | set(signals_b))
+
+            for key in keys:
+                va = signals_a.get(key, 0.0)
+                vb = signals_b.get(key, 0.0)
+                delta = vb - va
+                threshold = 0.1
+                if self._schema:
+                    sig_def = self._schema.get_def(key)
+                    if sig_def:
+                        threshold = sig_def.delta_threshold
+
+                display_key = key[:10]
+                text.append(f"{display_key:10s} ", style="dim")
+
+                if abs(delta) > threshold:
+                    arrow = "\u2191" if delta > 0 else "\u2193"
+                    sign = "+" if delta >= 0 else ""
+                    text.append(f"{arrow} {sign}{delta:.3f}", style="bold red")
+                elif abs(delta) > threshold * 0.5:
+                    arrow = "\u2191" if delta > 0 else "\u2193"
+                    sign = "+" if delta >= 0 else ""
+                    text.append(f"{arrow} {sign}{delta:.3f}", style="yellow")
+                else:
+                    sign = "+" if delta >= 0 else ""
+                    text.append(f"  {sign}{delta:.3f}", style="dim")
+                text.append("\n")
+
+        if hypothesis:
+            text.append("\n")
+            text.append(f"\u2192 {hypothesis}\n", style="italic")
+
+        content.update(text)

psystack/tui/widgets/tier_indicator.py

@@ -0,0 +1,44 @@
+"""Tier indicator — displays attribution tier with visual differentiation."""
+
+from __future__ import annotations
+
+from rich.text import Text
+
+from textual.widgets import Static
+
+_TIER_MESSAGES = {
+    "tier_0": "Correlational only — no component isolation performed",
+    "tier_1": "Component-isolated — swap tests narrow the cause",
+    "tier_2": "Counterfactual — cross-validated with swap experiments",
+    "tier_3": "Mechanistic — causal chain fully traced",
+}
+
+_TIER_STYLES = {
+    "tier_0": ("bold red", "T0"),
+    "tier_1": ("bold yellow", "T1"),
+    "tier_2": ("bold green", "T2"),
+    "tier_3": ("bold cyan", "T3"),
+}
+
+
+class TierIndicator(Static):
+    """Shows the current attribution tier with colored badge and context."""
+
+    DEFAULT_CSS = """
+    TierIndicator {
+        height: auto;
+        padding: 1;
+        background: $boost;
+    }
+    """
+
+    def set_tier(self, tier: str) -> None:
+        msg = _TIER_MESSAGES.get(tier, f"Unknown tier: {tier}")
+        style, badge = _TIER_STYLES.get(tier, ("bold", "T?"))
+        label = tier.replace("_", " ").title()
+
+        text = Text()
+        text.append(f" {badge} ", style=f"{style} reverse")
+        text.append(f" {label}: ", style="bold")
+        text.append(msg)
+        self.update(text)

psystack/tui/widgets/track_map.py

@@ -0,0 +1,137 @@
+"""Braille-rasterized track map for progress visualization."""
+
+from __future__ import annotations
+
+from rich.text import Text
+
+
+# Braille dot positions: (col_offset, row_offset) -> bit index
+# Unicode braille: U+2800 + bitmask
+# Dot layout per cell (2 cols x 4 rows):
+#   (0,0)=0x01  (1,0)=0x08
+#   (0,1)=0x02  (1,1)=0x10
+#   (0,2)=0x04  (1,2)=0x20
+#   (0,3)=0x40  (1,3)=0x80
+_DOT_MAP = {
+    (0, 0): 0x01, (1, 0): 0x08,
+    (0, 1): 0x02, (1, 1): 0x10,
+    (0, 2): 0x04, (1, 2): 0x20,
+    (0, 3): 0x40, (1, 3): 0x80,
+}
+
+
+def _bresenham(x0: int, y0: int, x1: int, y1: int) -> list[tuple[int, int]]:
+    """Integer Bresenham line rasterization."""
+    points: list[tuple[int, int]] = []
+    dx = abs(x1 - x0)
+    dy = abs(y1 - y0)
+    sx = 1 if x0 < x1 else -1
+    sy = 1 if y0 < y1 else -1
+    err = dx - dy
+    while True:
+        points.append((x0, y0))
+        if x0 == x1 and y0 == y1:
+            break
+        e2 = 2 * err
+        if e2 > -dy:
+            err -= dy
+            x0 += sx
+        if e2 < dx:
+            err += dx
+            y0 += sy
+    return points
+
+
+class BrailleTrackRaster:
+    """Pre-rasterize a track shape into a braille pixel grid.
+
+    Each pixel records its progress value (0.0–1.0) along the track.
+    Rendering sweeps the grid, coloring pixels before the cutoff bright
+    and after it dim.
+    """
+
+    def __init__(
+        self,
+        points: list[tuple[float, float]],
+        cols: int = 25,
+        rows: int = 10,
+    ) -> None:
+        self.cols = cols
+        self.rows = rows
+        # Pixel grid dimensions (2 dots per col, 4 dots per row)
+        self.px_w = cols * 2
+        self.px_h = rows * 4
+
+        # pixel_progress: maps (px, py) -> progress float (0.0–1.0)
+        self.pixel_progress: dict[tuple[int, int], float] = {}
+
+        if len(points) < 2:
+            return
+
+        # Normalize points to pixel grid, preserving aspect ratio
+        xs = [p[0] for p in points]
+        ys = [p[1] for p in points]
+        min_x, max_x = min(xs), max(xs)
+        min_y, max_y = min(ys), max(ys)
+        range_x = max_x - min_x or 1.0
+        range_y = max_y - min_y or 1.0
+
+        # Preserve aspect ratio
+        scale = min((self.px_w - 1) / range_x, (self.px_h - 1) / range_y)
+        # Center in the grid
+        off_x = (self.px_w - 1 - range_x * scale) / 2
+        off_y = (self.px_h - 1 - range_y * scale) / 2
+
+        def to_px(x: float, y: float) -> tuple[int, int]:
+            px = int((x - min_x) * scale + off_x)
+            py = int((y - min_y) * scale + off_y)
+            return (
+                max(0, min(self.px_w - 1, px)),
+                max(0, min(self.px_h - 1, py)),
+            )
+
+        # Walk consecutive pairs, rasterize with Bresenham
+        n = len(points)
+        for i in range(n - 1):
+            x0, y0 = to_px(*points[i])
+            x1, y1 = to_px(*points[i + 1])
+            progress_start = i / (n - 1)
+            progress_end = (i + 1) / (n - 1)
+            line_pts = _bresenham(x0, y0, x1, y1)
+            for j, (px, py) in enumerate(line_pts):
+                t = progress_start + (progress_end - progress_start) * (j / max(len(line_pts) - 1, 1))
+                if (px, py) not in self.pixel_progress:
+                    self.pixel_progress[(px, py)] = t
+
+    def render(
+        self,
+        progress: float,
+        color: str = "cyan",
+        dim_color: str = "grey37",
+    ) -> Text:
+        """Render the track with pixels up to `progress` in color, rest dim."""
+        text = Text()
+        for row in range(self.rows):
+            for col in range(self.cols):
+                mask = 0
+                min_prog = 2.0  # sentinel > 1.0
+                for (dc, dr), bit in _DOT_MAP.items():
+                    px = col * 2 + dc
+                    py = row * 4 + dr
+                    if (px, py) in self.pixel_progress:
+                        mask |= bit
+                        p = self.pixel_progress[(px, py)]
+                        if p < min_prog:
+                            min_prog = p
+
+                if mask == 0:
+                    text.append(" ")
+                else:
+                    ch = chr(0x2800 + mask)
+                    style = color if min_prog <= progress else dim_color
+                    text.append(ch, style=style)
+
+            if row < self.rows - 1:
+                text.append("\n")
+
+        return text

psystack/tui/widgets/transport_bar.py

@@ -0,0 +1,152 @@
+"""Transport bar — step scrubber and event navigation controls."""
+
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.message import Message
+from textual.reactive import reactive
+from textual.widgets import Button, ProgressBar, Static
+
+
+class TransportBar(Vertical):
+    """Bottom transport bar — single row with step controls and event nav."""
+
+    current_step: reactive[int] = reactive(0)
+    max_step: reactive[int] = reactive(0)
+
+    class StepChanged(Message):
+        def __init__(self, step: int) -> None:
+            self.step = step
+            super().__init__()
+
+    class EventSelected(Message):
+        def __init__(self, event_idx: int) -> None:
+            self.event_idx = event_idx
+            super().__init__()
+
+    class EpisodeNav(Message):
+        def __init__(self, direction: int) -> None:
+            self.direction = direction
+            super().__init__()
+
+    class CycleRequested(Message):
+        def __init__(self, target: str) -> None:
+            self.target = target
+            super().__init__()
+
+    DEFAULT_CSS = """
+    TransportBar {
+        height: auto;
+        background: $boost;
+        dock: bottom;
+        border-top: hkey $panel;
+    }
+    TransportBar Horizontal {
+        height: 3;
+        padding: 0 1;
+        align: left middle;
+    }
+    TransportBar .tb-label {
+        width: auto;
+        padding: 0 1;
+    }
+    TransportBar #tb-episode-label {
+        width: auto;
+        text-style: bold;
+        padding: 0 1;
+        color: $accent;
+    }
+    TransportBar .tb-step {
+        width: auto;
+        text-style: bold;
+        padding: 0 1;
+    }
+    TransportBar ProgressBar {
+        width: 1fr;
+        padding: 0 1;
+    }
+    TransportBar Button {
+        min-width: 3;
+        height: 1;
+        margin: 0 0;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(id="tb-row-1"):
+            yield Button("<Ep", id="tb-prev-episode")
+            yield Static("", id="tb-episode-label", classes="tb-label")
+            yield Button("Ep>", id="tb-next-episode")
+            yield Button("<<", id="tb-step-back-10")
+            yield Button("<", id="tb-prev-step")
+            yield Static("t=0", id="tb-step-display", classes="tb-step")
+            yield Button(">", id="tb-next-step")
+            yield Button(">>", id="tb-step-fwd-10")
+            yield ProgressBar(total=100, show_eta=False, show_percentage=False, id="tb-progress")
+            yield Static("", id="tb-range", classes="tb-label")
+            yield Button("[", id="tb-prev-event")
+            yield Button("]", id="tb-next-event")
+
+    def watch_current_step(self, step: int) -> None:
+        try:
+            display = self.query_one("#tb-step-display", Static)
+        except Exception:
+            return
+        display.update(f"Step {step}")
+        if self.max_step > 0:
+            progress = self.query_one("#tb-progress", ProgressBar)
+            progress.update(total=self.max_step, progress=step)
+
+    def watch_max_step(self, value: int) -> None:
+        try:
+            label = self.query_one("#tb-range", Static)
+        except Exception:
+            return
+        label.update(f"/{value}")
+
+    def update_episode_label(self, episode_num: int, episode_total: int) -> None:
+        """Update the persistent episode label (D-04)."""
+        label = self.query_one("#tb-episode-label", Static)
+        label.update(f"Ep {episode_num}/{episode_total}")
+
+    def update_cycle_label(self, target: str, text: str) -> None:
+        """No-op — cycling buttons moved to ActionBar."""
+        pass
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        bid = event.button.id
+        if bid == "tb-prev-step":
+            self.step_backward()
+        elif bid == "tb-next-step":
+            self.step_forward()
+        elif bid == "tb-step-back-10":
+            self.step_backward(10)
+        elif bid == "tb-step-fwd-10":
+            self.step_forward(10)
+        elif bid == "tb-prev-event":
+            self.post_message(self.EventSelected(-1))
+        elif bid == "tb-next-event":
+            self.post_message(self.EventSelected(1))
+        elif bid == "tb-prev-episode":
+            self.post_message(self.EpisodeNav(-1))
+        elif bid == "tb-next-episode":
+            self.post_message(self.EpisodeNav(1))
+
+    def step_forward(self, amount: int = 1) -> None:
+        new = min(self.current_step + amount, self.max_step)
+        if new != self.current_step:
+            self.current_step = new
+            self.post_message(self.StepChanged(new))
+
+    def step_backward(self, amount: int = 1) -> None:
+        new = max(self.current_step - amount, 0)
+        if new != self.current_step:
+            self.current_step = new
+            self.post_message(self.StepChanged(new))
+
+    def goto_step(self, step: int) -> None:
+        step = max(0, min(step, self.max_step))
+        if step != self.current_step:
+            self.current_step = step
+            self.post_message(self.StepChanged(step))