shikiru-cli 0.2.0__py3-none-any.whl

shikiru/ui/popup.py

@@ -0,0 +1,311 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from textual.containers import Vertical
+from textual.css.scalar import Unit
+from textual.geometry import Size
+
+from shikiru.ui.keys import key_hint
+from shikiru.ui.screen import widget_is_attached
+
+if TYPE_CHECKING:
+    from rich.text import Text
+    from textual import events
+    from textual.widget import Widget
+
+POPUP_FRAME_CLASS = "popup-frame"
+POPUP_HEADER_CLASS = "popup-header"
+POPUP_TITLE_CLASS = "popup-title"
+POPUP_CLOSE_CLASS = "popup-close-control"
+POPUP_RULE_CLASS = "popup-rule"
+POPUP_BODY_CLASS = "popup-body"
+POPUP_SECONDARY_CLASS = "popup-secondary"
+POPUP_EDIT_CLASS = "popup-edit"
+POPUP_ROW_CLASS = "palette-row"
+POPUP_CLOSE_LABEL = "Esc \N{MULTIPLICATION SIGN}"
+
+
+def popup_close_label() -> Text:
+    """Return the Esc close label with its key in the key style."""
+    return key_hint(POPUP_CLOSE_LABEL)
+
+
+class PopupFrame(Vertical):
+    """Keep a content-sized popup frame stable when its screen is resized."""
+
+    def __init__(
+        self,
+        *children: Widget,
+        name: str | None = None,
+        widget_id: str | None = None,
+        classes: str | None = None,
+        disabled: bool = False,
+        markup: bool = True,
+    ) -> None:
+        super().__init__(
+            *children,
+            name=name,
+            id=widget_id,
+            classes=classes,
+            disabled=disabled,
+            markup=markup,
+        )
+        self._content_ready = False
+        self._preferred_size: Size | None = None
+        self._applied_size: Size | None = None
+
+    def content_ready(self) -> None:
+        """Mark meaningful initial content as ready for preferred-size capture."""
+        if not self.is_mounted or not widget_is_attached(self):
+            return
+        self._content_ready = True
+        self.call_after_refresh(self.update_preferred_size)
+
+    def reset_preferred_size(self) -> None:
+        """Forget the prior measurement when a popup changes content purpose."""
+        self._preferred_size = None
+        self._applied_size = None
+        self._content_ready = False
+        self.remove_class("stable")
+        self.styles.width = "auto"
+        self.styles.height = "auto"
+
+    def on_resize(self, event: events.Resize) -> None:
+        del event
+        self.call_after_refresh(self.update_preferred_size)
+
+    def update_preferred_size(self) -> None:
+        """Capture an unclamped outer size once, then clamp it to the current screen."""
+        if not self.is_mounted or not widget_is_attached(self):
+            return
+        viewport = self.screen.size
+        if self._preferred_size is None:
+            self._remember_preferred_size()
+        if self._preferred_size is not None:
+            self._apply_preferred_size(viewport)
+
+    def _remember_preferred_size(self) -> None:
+        if not self._content_ready:
+            return
+        height = self.styles.height
+        children = tuple(self.children)
+        viewport = self.screen.size
+        natural_width = (
+            max(
+                (child.virtual_size.width + child.styles.margin.width for child in children),
+                default=0,
+            )
+            + self.styles.gutter.width
+        )
+        max_width = self.styles.max_width
+        max_width_cells = max_width.cells if max_width is not None else None
+        preferred_width = max(
+            self.outer_size.width,
+            max_width_cells if max_width_cells is not None else natural_width,
+        )
+        relative_height = height is not None and height.unit in {
+            Unit.PERCENT,
+            Unit.HEIGHT,
+            Unit.VIEW_HEIGHT,
+        }
+        height_clamped = self.outer_size.height >= viewport.height - self.styles.margin.height
+        if relative_height and not height_clamped:
+            natural_height = self.outer_size.height
+        elif relative_height:
+            natural_height = sum(_preferred_child_height(child) for child in children)
+            natural_height += self.styles.gutter.height
+        else:
+            content_width = max(0, preferred_width - self.styles.gutter.width)
+            natural_height = sum(
+                _preferred_child_height_at_width(child, viewport, content_width)
+                for child in children
+            )
+            natural_height += self.styles.gutter.height
+        preferred_height = (
+            natural_height
+            if relative_height and height_clamped
+            else max(self.outer_size.height, natural_height)
+        )
+        self._preferred_size = Size(
+            preferred_width,
+            preferred_height,
+        )
+        self.add_class("stable")
+
+    def _apply_preferred_size(self, viewport: Size) -> None:
+        if self._preferred_size is None:
+            return
+        margin = self.styles.margin
+        minimum_height = sum(_minimum_child_height(child) for child in self.children)
+        minimum_height += self.styles.gutter.height
+        size = Size(
+            max(1, min(self._preferred_size.width, viewport.width - margin.width)),
+            max(
+                1,
+                min(
+                    max(self._preferred_size.height, minimum_height),
+                    viewport.height - margin.height,
+                ),
+            ),
+        )
+        if size != self._applied_size:
+            self.styles.width = size.width
+            self.styles.height = size.height
+            self._applied_size = size
+
+
+def _preferred_child_height(child: Widget) -> int:
+    if not child.display:
+        height = child.styles.height
+        fixed_height = height.cells if height is not None else None
+        return (fixed_height or 0) + child.styles.margin.height
+    height = child.styles.height
+    fixed_height = height.cells if height is not None else None
+    return (
+        max(child.outer_size.height, child.virtual_size.height, fixed_height or 0)
+        + child.styles.margin.height
+    )
+
+
+def _preferred_child_height_at_width(child: Widget, viewport: Size, width: int) -> int:
+    if not child.display:
+        return _preferred_child_height(child)
+    content_width = max(0, width - child.styles.gutter.width)
+    content_height = child.get_content_height(Size(content_width, 0), viewport, content_width)
+    height = child.styles.height
+    fixed_height = height.cells if height is not None else None
+    return (
+        max(
+            child.outer_size.height,
+            fixed_height or 0,
+            content_height + child.styles.gutter.height,
+        )
+        + child.styles.margin.height
+    )
+
+
+def _minimum_child_height(child: Widget) -> int:
+    if not child.display:
+        return 0
+    height = child.styles.height
+    fixed_height = height.cells if height is not None else None
+    minimum_height = child.styles.min_height
+    minimum_height_cells = minimum_height.cells if minimum_height is not None else None
+    flexible_height = height is not None and height.unit is Unit.FRACTION
+    outer_height = 0 if flexible_height else child.outer_size.height
+    return (
+        max(outer_height, fixed_height or 0, minimum_height_cells or 0) + child.styles.margin.height
+    )
+
+
+POPUP_BUTTON_CSS = """
+.popup-frame Button.-style-default {
+    color: $primary-text; background: $surface; border: solid $neutral-border;
+    border-top: solid $neutral-border; border-bottom: solid $neutral-border;
+    text-style: none;
+}
+.popup-frame Button.-style-default.-primary {
+    border: solid $neutral-border;
+    border-top: solid $neutral-border; border-bottom: solid $neutral-border;
+}
+.popup-frame Button.-style-default:focus,
+.popup-frame Button.-style-default.-primary:focus {
+    color: $primary-text; background: $selected-surface;
+    border: solid $focus; border-top: solid $focus; border-bottom: solid $focus;
+    text-style: reverse;
+}
+.popup-frame Button.-style-default:disabled,
+.popup-frame Button.-style-default.-primary:disabled {
+    color: $secondary-text; background: $surface;
+    border: solid $neutral-border;
+    border-top: solid $neutral-border; border-bottom: solid $neutral-border;
+    text-opacity: 76%;
+}
+"""
+
+POPUP_CONTROL_CSS = """
+.popup-frame Button:focus {
+    color: $primary-text; background: $selected-surface; text-style: reverse;
+}
+.popup-frame Button:disabled { color: $secondary-text; }
+.popup-frame SelectCurrent {
+    border: solid $neutral-border; padding: 0 1; background: $detail-surface;
+}
+.popup-frame Select:focus > SelectCurrent,
+.popup-frame Select.-expanded > SelectCurrent {
+    border: solid $focus; background: $selected-surface;
+}
+.popup-frame SelectOverlay {
+    border: solid $neutral-border; scrollbar-size-vertical: $scrollbar-width;
+}
+.popup-frame SelectOverlay:focus { border: solid $focus; }
+.popup-frame TextArea { scrollbar-size-vertical: $scrollbar-width; }
+.popup-frame TextArea.popup-edit {
+    height: auto; min-height: 2; max-height: 6; padding: 0;
+    border: none; border-bottom: solid $neutral-border; background: $surface;
+}
+.popup-frame TextArea.popup-edit > .text-area--cursor-line { background: transparent; }
+.popup-frame TextArea.popup-edit:focus {
+    border: none; border-bottom: solid $focus; background: $selected-surface;
+}
+.popup-frame Select:disabled > SelectCurrent { color: $secondary-text; }
+.popup-frame Button.popup-close-control {
+    width: auto; min-width: 5; height: 1; margin: 0; padding: 0 1;
+    border: none; border-top: none; border-bottom: none;
+    background: $surface; color: $primary-text; text-style: none;
+}
+.popup-frame Button.popup-close-control.-style-default:focus {
+    border: none; border-top: none; border-right: none; border-bottom: none; border-left: none;
+    background: $selected-surface; color: $primary-text; text-style: reverse;
+}
+"""
+
+POPUP_COMPACT_CONTROL_CSS = """
+.palette-row { layout: horizontal; height: auto; margin-bottom: 0; }
+.palette-row Label { width: 9; height: 1; color: $secondary-text; text-style: none; }
+.palette-row Input, .palette-row Select { width: 1fr; }
+.palette-row Input {
+    height: 1; border: none; padding: 0 1; background: $surface;
+}
+.palette-row Input:focus {
+    border: none; background: $selected-surface; text-style: none;
+}
+.popup-frame .palette-row SelectCurrent {
+    height: 1; border: none; padding: 0 1; background: $detail-surface;
+}
+.popup-frame .palette-row Select:focus > SelectCurrent,
+.popup-frame .palette-row Select.-expanded > SelectCurrent {
+    border: none; background: $selected-surface;
+}
+"""
+
+POPUP_CSS = (
+    """
+.popup-frame {
+    width: 100%; max-width: 64; height: auto; max-height: 100%; margin: 1 2;
+    padding: 1 2; border: solid $steel-blue; background: $surface; color: $primary-text;
+}
+.popup-header { width: 100%; height: 1; }
+.popup-title { width: 1fr; height: 1; color: $primary-text; text-style: bold; }
+.popup-frame Rule.popup-rule { width: 100%; height: 1; margin: 0; color: $neutral-border; }
+.popup-body {
+    height: auto; max-height: 1fr; min-height: 0; padding: 0;
+}
+.popup-frame.stable > .popup-body { height: 1fr; }
+.popup-body, .popup-frame #task-detail-body {
+    overflow-x: hidden; overflow-y: auto;
+    scrollbar-size-horizontal: 0; scrollbar-size-vertical: $scrollbar-width;
+}
+.popup-secondary { color: $secondary-text; }
+"""
+    + POPUP_BUTTON_CSS
+    + POPUP_CONTROL_CSS
+)
+
+
+def prepare_popup(screen: Widget) -> None:
+    screen.styles.align_horizontal = "center"
+    screen.styles.align_vertical = "middle"
+    screen.styles.background = "transparent"
+    screen.styles.padding = 0

shikiru/ui/quota_status.py

@@ -0,0 +1,26 @@
+"""The status line of an agent pane whose turn or dispatch waits on a quota block."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from shikiru.domain.quota_waits import QUOTA_BANNER_SEPARATOR, quota_reset_clock
+from shikiru.ui.glyphs import GLYPH_QUOTA
+
+if TYPE_CHECKING:
+    from datetime import datetime
+
+    from shikiru.domain.quota_waits import QuotaAction
+
+QUOTA_BLOCKED_STATUS = "Quota blocked"
+
+
+def quota_status_text(action: QuotaAction | None, at: datetime | None, now: datetime) -> str:
+    """Return the pane status line; the engine's next `action` and its time show only when known.
+
+    `at` and `now` are rendered in the zone they carry, so callers pass the viewer's local time.
+    """
+    text = f"{GLYPH_QUOTA} {QUOTA_BLOCKED_STATUS}"
+    if action is None or at is None:
+        return text
+    return f"{text}{QUOTA_BANNER_SEPARATOR}{action.value} {quota_reset_clock(at, now)}"

shikiru/ui/recent_window.py

@@ -0,0 +1,78 @@
+"""Paged window over the most recent terminal tasks."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class RecentWindow:
+    """A fixed-size window at `offset` over `total` most recent tasks, newest first."""
+
+    offset: int
+    size: int
+    total: int
+
+    @property
+    def shown(self) -> int:
+        """Return how many tasks the window holds; the oldest page may be short."""
+        return max(min(self.size, self.total - self.offset), 0)
+
+    @property
+    def paged(self) -> bool:
+        """Return whether more tasks exist than one window holds."""
+        return self.total > self.size
+
+    @property
+    def has_later(self) -> bool:
+        """Return whether a newer page exists."""
+        return self.offset > 0
+
+    @property
+    def has_earlier(self) -> bool:
+        """Return whether an older page exists."""
+        return self.offset + self.size < self.total
+
+    def at_page_of(self, position: int) -> RecentWindow:
+        """Return the window whose page holds the task at absolute `position`."""
+        return RecentWindow(position // self.size * self.size, self.size, self.total)
+
+    def clamped(self) -> RecentWindow:
+        """Return the window moved to the last page when `offset` lies past the end."""
+        return self.at_page_of(max(min(self.offset, self.total - 1), 0))
+
+
+@dataclass(frozen=True, slots=True)
+class StepTarget:
+    """Where Up/Down lands: a visible row, or a Recent task on another page."""
+
+    visible_index: int | None = None
+    recent_position: int | None = None
+
+
+def step_selection(
+    active_count: int,
+    window: RecentWindow,
+    current: int | None,
+    step: int,
+) -> StepTarget:
+    """Step one row through active rows then the visible Recent rows, paging at window edges.
+
+    `current` indexes that visible order, or is `None` when the selection is not visible.
+    Entering Recent from the active rows never pages; leaving the window pages by one task.
+    """
+    count = active_count + window.shown
+    if current is None:
+        return StepTarget(visible_index=0 if step > 0 else count - 1)
+    if window.shown:
+        if current == count - 1 and step > 0:
+            if window.has_earlier:
+                return StepTarget(recent_position=window.offset + window.shown)
+            if active_count == 0:
+                return StepTarget(recent_position=0)
+        if current == active_count and step < 0:
+            if window.has_later:
+                return StepTarget(recent_position=window.offset - 1)
+            if active_count == 0:
+                return StepTarget(recent_position=window.total - 1)
+    return StepTarget(visible_index=(current + step) % count)

shikiru/ui/screen.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Protocol, runtime_checkable
+
+from textual.dom import NoScreen
+from textual.screen import Screen
+
+if TYPE_CHECKING:
+    from textual.widget import Widget
+
+
+@runtime_checkable
+class ConditionalTabStop(Protocol):
+    """A widget that Tab and Shift+Tab visit only while `is_tab_stop()` holds."""
+
+    def is_tab_stop(self) -> bool: ...
+
+
+class TabStopScreen(Screen[object]):
+    """Keep widgets that are not stops now out of the Tab order, except the focused widget."""
+
+    @property
+    def focus_chain(self) -> list[Widget]:
+        focused = self.focused
+        return [
+            widget
+            for widget in super().focus_chain
+            if widget is focused
+            or not isinstance(widget, ConditionalTabStop)
+            or widget.is_tab_stop()
+        ]
+
+
+def is_first_child(widget: Widget) -> bool:
+    return widget.parent is not None and widget.parent.children[0] is widget
+
+
+def widget_is_attached(widget: Widget) -> bool:
+    return _screen_for(widget) is not None
+
+
+def widget_is_on_screen(widget: Widget, screen: object) -> bool:
+    return _screen_for(widget) is screen
+
+
+def widget_is_current(widget: Widget) -> bool:
+    screen = _screen_for(widget)
+    return screen is not None and screen.is_current
+
+
+def _screen_for(widget: Widget) -> Screen[object] | None:
+    if not widget.is_attached:
+        return None
+    try:
+        return widget.screen
+    except NoScreen:
+        return None

shikiru/ui/section.py

@@ -0,0 +1,193 @@
+"""Rule-and-heading sections with labelled, separator-wrapped rows shared by the panels."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+from typing import TYPE_CHECKING
+
+from rich.cells import cell_len
+from rich.console import Group, RenderableType
+from rich.rule import Rule
+from rich.table import Table
+from rich.text import Text
+
+from shikiru.ui.age import AGE_NOW
+from shikiru.ui.tokens import (
+    AMBER,
+    NEUTRAL_BORDER_COLOR,
+    PRIMARY_TEXT_COLOR,
+    SECONDARY_TEXT_COLOR,
+    STEEL_BLUE,
+    STYLE_BOLD,
+)
+
+if TYPE_CHECKING:
+    from rich.console import Console, ConsoleOptions, RenderResult
+
+GROUP_SEPARATOR = " · "
+LABEL_GAP = 1
+MIN_VALUE_WIDTH = 24
+VALUE_OVERFLOW = "fold"
+HEADING_MIN_GAP = 1
+STACKED_BELOW_WIDTH = 32
+OBSERVED_WORD = "observed"
+AGO_WORD = "ago"
+UNKNOWN_AGE = "\N{EN DASH}"
+STALE_WORD = "stale"
+FAILED_WORD = "failed"
+UNAVAILABLE_WORD = "unavailable"
+BOLD_STEEL = f"{STYLE_BOLD} {STEEL_BLUE}"
+BOLD_PRIMARY = f"{STYLE_BOLD} {PRIMARY_TEXT_COLOR}"
+
+Row = tuple[Text, tuple[Text, ...]]
+
+
+def grey(text: str) -> Text:
+    """Return `text` in the secondary grey."""
+    return Text(text, style=SECONDARY_TEXT_COLOR)
+
+
+def row_name(text: str) -> Text:
+    """Return `text` as a bold white row name."""
+    return Text(text, style=BOLD_PRIMARY)
+
+
+def number(value: str) -> Text:
+    """Return `value` as a bold cyan figure."""
+    return Text(value, style=BOLD_STEEL)
+
+
+def key_label(key: str, label: str) -> Text:
+    """Return `key` in the bold cyan key style followed by its grey `label`."""
+    return Text.assemble((key, BOLD_STEEL), grey(f" {label}"))
+
+
+def observed_text(observed_ago: str) -> str:
+    """Return `observed <age> ago`, or `observed now`."""
+    suffix = "" if observed_ago == AGE_NOW else f" {AGO_WORD}"
+    return f"{OBSERVED_WORD} {observed_ago}{suffix}"
+
+
+def observation(observed_ago: str, *, stale: bool) -> Text | None:
+    """Return the amber `stale · observed <age> ago` heading note, or nothing unless `stale`."""
+    if not stale:
+        return None
+    return Text(f"{STALE_WORD}{GROUP_SEPARATOR}{observed_text(observed_ago)}", style=AMBER)
+
+
+def state_line(word: str, colour: str, error: str | None) -> Text:
+    """Return a sampling state `word` in `colour`, with any recorded `error` after it."""
+    detail = f"{GROUP_SEPARATOR}{error}" if error else ""
+    return Text(f"{word}{detail}", style=colour)
+
+
+def wrap_groups(
+    groups: tuple[Text, ...], width: int | None, separator: str = GROUP_SEPARATOR
+) -> Text:
+    """Join `groups` with grey `separator`s, breaking lines only between groups."""
+    result = Text()
+    line_width = 0
+    for group in groups:
+        gap = separator if line_width else ""
+        group_width = cell_len(group.plain)
+        exceeds_width = line_width + cell_len(gap) + group_width > width if width else False
+        if width is not None and line_width and exceeds_width:
+            result.append("\n")
+            line_width = 0
+            gap = ""
+        result.append(gap, style=SECONDARY_TEXT_COLOR)
+        result.append(group)
+        line_width += cell_len(gap) + group_width
+    return result
+
+
+class WrappedGroups:
+    """Renderable that wraps its groups with `separator` at the width it is rendered in."""
+
+    def __init__(self, groups: tuple[Text, ...], separator: str = GROUP_SEPARATOR) -> None:
+        self._groups = groups
+        self._separator = separator
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        del console
+        yield wrap_groups(self._groups, options.max_width, self._separator)
+
+
+def labelled_rows(
+    rows: list[Row], width: int, label_width: int, stack_below: int = STACKED_BELOW_WIDTH
+) -> RenderableType:
+    """Lay rows out as a label column and wrapped values, stacked below `stack_below` cells."""
+    value_width = width - label_width - LABEL_GAP
+    value_indent = labelled_value_indent(width, label_width, stack_below)
+    if value_indent == 0 and width < stack_below and label_width <= width - LABEL_GAP:
+        return Group(*_stacked_lines(rows, width))
+    if value_indent == 0:
+        grid = Table.grid()
+        grid.add_column(width=width, overflow=VALUE_OVERFLOW)
+        for label, groups in rows:
+            if label.plain:
+                grid.add_row(label)
+            grid.add_row(wrap_groups(groups, width))
+        return grid
+    grid = Table.grid()
+    grid.add_column(width=label_width + LABEL_GAP, no_wrap=True)
+    grid.add_column(width=value_width, overflow=VALUE_OVERFLOW)
+    for label, groups in rows:
+        grid.add_row(label, wrap_groups(groups, value_width))
+    return grid
+
+
+def labelled_value_indent(
+    width: int, label_width: int, stack_below: int = STACKED_BELOW_WIDTH
+) -> int:
+    """Return the value cell's indent when `labelled_rows` has a value column."""
+    value_width = width - label_width - LABEL_GAP
+    if value_width < MIN_VALUE_WIDTH:
+        return 0
+    if width < stack_below and label_width <= width - LABEL_GAP:
+        return 0
+    return label_width + LABEL_GAP
+
+
+def _stacked_lines(rows: list[Row], width: int) -> list[Text]:
+    lines: list[Text] = []
+    for label, groups in rows:
+        if label.plain:
+            lines.append(label)
+        lines.append(wrap_groups(groups, width))
+    return lines
+
+
+@dataclass(frozen=True)
+class Section:
+    """Render `body` below an optional rule and a heading, with an optional `trailing`."""
+
+    title: str
+    body: RenderableType
+    trailing: Text | None = None
+    ruled: bool = True
+    title_style: str = SECONDARY_TEXT_COLOR
+
+    def with_ruled(self, *, ruled: bool) -> Section:
+        """Return this section drawn with or without its leading rule."""
+        return replace(self, ruled=ruled)
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        """Yield the rule when ruled, the heading and the body."""
+        del console
+        if self.ruled:
+            yield Rule(style=NEUTRAL_BORDER_COLOR)
+        yield self._heading(options.max_width)
+        yield self.body
+
+    def _heading(self, width: int) -> RenderableType:
+        title = Text()
+        title.append(self.title, style=self.title_style)
+        if self.trailing is None:
+            return title
+        gap = width - cell_len(title.plain) - cell_len(self.trailing.plain)
+        if gap < HEADING_MIN_GAP:
+            return Group(title, self.trailing)
+        title.append(" " * gap)
+        title.append(self.trailing)
+        return title