shikiru-cli 0.2.0__py3-none-any.whl

shikiru/dashboard/resolution_view.py

@@ -0,0 +1,302 @@
+"""Renderables of the escalation resolution screen: title, Decision, Choose, choices, evidence."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import StrEnum, auto
+from typing import TYPE_CHECKING
+
+from rich.console import Group, RenderableType
+from rich.table import Table
+from rich.text import Text
+
+from shikiru.domain.attempts import AttemptItem, AttemptKind, AttemptTone
+from shikiru.domain.escalation_panel import ChoiceKind
+from shikiru.ui.fold import fold_arrow, fold_toggle_hint
+from shikiru.ui.keys import key_hint
+from shikiru.ui.section import (
+    BOLD_STEEL,
+    GROUP_SEPARATOR,
+    Row,
+    Section,
+    grey,
+    key_label,
+    labelled_rows,
+    row_name,
+)
+from shikiru.ui.tokens import (
+    AMBER,
+    DUSTY_ROSE,
+    PRIMARY_TEXT_COLOR,
+    SAGE,
+    SECONDARY_TEXT_COLOR,
+    STEEL_BLUE,
+    STYLE_BOLD,
+)
+
+if TYPE_CHECKING:
+    from rich.console import Console, ConsoleOptions, RenderResult
+
+    from shikiru.domain.escalation_panel import PanelChoice, ResolutionPanel
+
+NARROW_MAX_COLUMNS = 48
+FOLDED_MAX_COLUMNS = 40
+TINY_MAX_ROWS = 8
+_LABEL_WIDTH = 9
+_MARK_WIDTH = 3
+_RECOMMENDED_STAR = "\N{BLACK STAR}"
+_OWN_ANSWER_LABEL = "Write your own answer\N{HORIZONTAL ELLIPSIS}"
+_ACCEPT_LABEL = "Accept"
+_RETRY_LABEL = "Retry"
+_CANCEL_LABEL = "Cancel task"
+_CANCEL_CONFIRM_LABEL = "Press Enter again to cancel"
+_DECISION_TITLE = "Decision"
+_CHOOSE_TITLE = "Choose"
+_SELECT_HINT = "\N{UPWARDS ARROW}\N{DOWNWARDS ARROW} select"
+_SEND_HINT = "Enter send"
+_EXPAND_HINT = "Enter expand"
+_BACK_HINT = "\N{UPWARDS ARROW} choices"
+_COLLAPSE_HINT = "Enter collapse"
+_EDIT_HINT = "Enter edit"
+_CHOICE_HINTS = frozenset({_SEND_HINT, _EDIT_HINT})
+_BOX_HINTS = ("Ctrl+S send", "Enter new line", "Esc back")
+_NEEDS_INPUT_MARK = "\N{LOWER RIGHT PENCIL}"
+_NEEDS_INPUT_TEXT = "needs your input"
+_DETAILS_TITLE = "Details"
+EXTRA_DETAILS_KEY = "o"
+_EXTRA_DETAILS_LABEL = "extra details"
+_TURNS_LABEL = "Turns"
+_PART_SEPARATOR = " \N{MIDDLE DOT} "
+_TURN_KINDS = frozenset({AttemptKind.TURN_OK, AttemptKind.TURN_FAILED, AttemptKind.VERDICT})
+_DETAIL_LABELS = {
+    AttemptKind.REASON: "Reason",
+    AttemptKind.ROUNDS: "Rounds",
+    AttemptKind.RECOVERY: "Recovery",
+    AttemptKind.PRODUCED: "Produced",
+    AttemptKind.OPERATOR: "Operator",
+}
+_TONE_STYLES = {
+    AttemptTone.PLAIN: PRIMARY_TEXT_COLOR,
+    AttemptTone.STEP: STEEL_BLUE,
+    AttemptTone.SUCCESS: SAGE,
+    AttemptTone.FAILURE: DUSTY_ROSE,
+    AttemptTone.REWORK: AMBER,
+}
+_WAITING_WORD = "waiting"
+_TITLE_WIDE = "Resolve escalation"
+_TITLE_NARROW = "Resolve"
+_LABEL_TASK = "Task"
+_LABEL_QUESTION = "Question"
+_LABEL_REASON = "Reason"
+
+_LABEL_STYLES = {
+    ChoiceKind.ANSWER_OPTION: STEEL_BLUE,
+    ChoiceKind.OWN_ANSWER: STEEL_BLUE,
+    ChoiceKind.RETRY: STEEL_BLUE,
+    ChoiceKind.ACCEPT: SAGE,
+    ChoiceKind.CANCEL: DUSTY_ROSE,
+}
+_FIXED_LABELS = {
+    ChoiceKind.OWN_ANSWER: _OWN_ANSWER_LABEL,
+    ChoiceKind.ACCEPT: _ACCEPT_LABEL,
+    ChoiceKind.RETRY: _RETRY_LABEL,
+    ChoiceKind.CANCEL: _CANCEL_LABEL,
+}
+
+
+class ResolutionLayout(StrEnum):
+    """How much of the panel a pane size leaves room for."""
+
+    WIDE = auto()
+    NARROW = auto()
+    FOLDED = auto()
+    TINY = auto()
+
+
+_FOLDED_LAYOUTS = frozenset({ResolutionLayout.FOLDED, ResolutionLayout.TINY})
+
+
+def layout_for(width: int, height: int) -> ResolutionLayout:
+    """Pick the layout for a screen of `width` by `height` cells."""
+    if height <= TINY_MAX_ROWS:
+        return ResolutionLayout.TINY
+    if width <= FOLDED_MAX_COLUMNS:
+        return ResolutionLayout.FOLDED
+    if width <= NARROW_MAX_COLUMNS:
+        return ResolutionLayout.NARROW
+    return ResolutionLayout.WIDE
+
+
+def resolution_title(
+    escalation_id: str, panel: ResolutionPanel | None, layout: ResolutionLayout
+) -> str:
+    """Return the popup title: ids, with task and reason folded in when the pane is small."""
+    if panel is None:
+        return GROUP_SEPARATOR.join((_TITLE_NARROW, escalation_id))
+    if layout in _FOLDED_LAYOUTS:
+        return GROUP_SEPARATOR.join((panel.task_id, panel.reason_label))
+    head = _TITLE_WIDE if layout is ResolutionLayout.WIDE else _TITLE_NARROW
+    return GROUP_SEPARATOR.join((head, escalation_id, panel.task_id))
+
+
+@dataclass(frozen=True)
+class _DecisionRows:
+    panel: ResolutionPanel
+    folded: bool
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        del console
+        panel = self.panel
+        if self.folded:
+            yield row_name(panel.question) if panel.question else grey(panel.cause or "")
+            return
+        rows: list[Row] = [
+            (grey(_LABEL_TASK), (row_name(panel.task_id), Text(panel.task_title))),
+        ]
+        if panel.question:
+            rows.append((grey(_LABEL_QUESTION), (row_name(panel.question),)))
+        if panel.cause or not panel.question:
+            reason = Text()
+            reason.append_text(row_name(panel.reason_label))
+            if panel.cause:
+                reason.append("\n")
+                reason.append(panel.cause, style=SECONDARY_TEXT_COLOR)
+            rows.append((grey(_LABEL_REASON), (reason,)))
+        yield labelled_rows(rows, options.max_width, _LABEL_WIDTH)
+
+
+def decision_renderable(
+    panel: ResolutionPanel, age: str, layout: ResolutionLayout
+) -> RenderableType:
+    """Return the Decision section, or only its question when the pane is folded."""
+    folded = layout in _FOLDED_LAYOUTS
+    rows = _DecisionRows(panel, folded)
+    if folded:
+        return rows
+    return Section(_DECISION_TITLE, rows, grey(f"{_WAITING_WORD} {age}"), ruled=False)
+
+
+def _hints(selected: PanelChoice, details_open: bool | None, *, editing: bool) -> tuple[str, ...]:
+    if editing:
+        return _BOX_HINTS
+    if details_open is not None:
+        return (_COLLAPSE_HINT if details_open else _EXPAND_HINT, _BACK_HINT)
+    editable = selected.kind is ChoiceKind.OWN_ANSWER or selected.needs_input
+    return (_SELECT_HINT, _EDIT_HINT if editable else _SEND_HINT)
+
+
+def choose_renderable(
+    selected: PanelChoice,
+    *,
+    details_open: bool | None = None,
+    editing: bool = False,
+    choosing_disabled: bool = False,
+) -> RenderableType:
+    """Return the Choose heading with its key hint.
+
+    `details_open` is `None` while the list has focus, else whether the focused Details is open.
+    `choosing_disabled` greys the `Enter` key of the list hint, which then does nothing.
+    """
+    hints = _hints(selected, details_open, editing=editing)
+    inert = choosing_disabled and details_open is None and not editing
+    parts = [
+        key_hint(hint, SECONDARY_TEXT_COLOR, enabled=not (inert and hint in _CHOICE_HINTS))
+        for hint in hints
+    ]
+    hint = Text(GROUP_SEPARATOR, style=SECONDARY_TEXT_COLOR).join(parts)
+    return Section(_CHOOSE_TITLE, Group(), hint, title_style=BOLD_STEEL)
+
+
+def _toned(item: AttemptItem) -> Text:
+    if item.kind is AttemptKind.EARLIER:
+        return grey(item.text)
+    return Text.assemble(*((part.text, _TONE_STYLES[part.tone]) for part in item.parts))
+
+
+def _turn_row(item: AttemptItem) -> Text:
+    styled = [(part.text, _TONE_STYLES[part.tone]) for part in item.parts]
+    role = (item.label, PRIMARY_TEXT_COLOR)
+    step = item.parts[0]
+    if step.tone is AttemptTone.STEP and item.text.startswith(step.text + _PART_SEPARATOR):
+        return Text.assemble(styled[0], _PART_SEPARATOR, role, *styled[1:])
+    return Text.assemble(role, _PART_SEPARATOR, *styled)
+
+
+def _detail_rows(items: tuple[AttemptItem, ...]) -> RenderableType:
+    grid = Table.grid()
+    grid.add_column(width=_LABEL_WIDTH + 1, no_wrap=True)
+    grid.add_column(ratio=1)
+    turns = [item for item in items if item.kind in _TURN_KINDS]
+    for item in items:
+        if item.kind in _TURN_KINDS:
+            if item is turns[0]:
+                grid.add_row(grey(_TURNS_LABEL), Group(*map(_turn_row, turns)))
+        elif item.kind is not AttemptKind.EARLIER:
+            grid.add_row(grey(_DETAIL_LABELS[item.kind]), _toned(item))
+    for item in items:
+        if item.kind is AttemptKind.EARLIER:
+            grid.add_row(Text(), _toned(item))
+    return grid
+
+
+def tried_renderable(
+    items: tuple[AttemptItem, ...], *, expanded: bool, extra_details: bool = False
+) -> RenderableType:
+    """Return the collapsible `Details` section with its toggle hint, without its rule.
+
+    An expanded section ends with the `extra details` hint when `extra_details` is set.
+    """
+    arrow = fold_arrow(expanded=expanded)
+    body: RenderableType = Group()
+    if expanded:
+        rows = _detail_rows(items)
+        body = (
+            Group(rows, key_label(EXTRA_DETAILS_KEY, _EXTRA_DETAILS_LABEL))
+            if extra_details
+            else rows
+        )
+    return Section(
+        f"{_DETAILS_TITLE} {arrow}",
+        body,
+        trailing=fold_toggle_hint(),
+        ruled=False,
+    )
+
+
+def starred_indexes(panel: ResolutionPanel) -> frozenset[int]:
+    """Return the rows to star: recommended ones, the own-answer row only when it stands alone."""
+    has_alternatives = any(c.kind is ChoiceKind.ANSWER_OPTION for c in panel.choices)
+    return frozenset(
+        index
+        for index, choice in enumerate(panel.choices)
+        if choice.recommended and not (has_alternatives and choice.kind is ChoiceKind.OWN_ANSWER)
+    )
+
+
+def _consequence(choice: PanelChoice, *, disabled: bool) -> Text:
+    if not choice.needs_input:
+        return grey(choice.consequence)
+    lead = Text(_NEEDS_INPUT_TEXT, style=SECONDARY_TEXT_COLOR if disabled else PRIMARY_TEXT_COLOR)
+    lead.append(GROUP_SEPARATOR + choice.consequence, style=SECONDARY_TEXT_COLOR)
+    return lead
+
+
+def choice_renderable(
+    choice: PanelChoice, *, starred: bool, armed: bool, disabled: bool
+) -> RenderableType:
+    """Return one choice row: star beside the label, its consequence beneath in grey."""
+    style = SECONDARY_TEXT_COLOR if disabled else _LABEL_STYLES[choice.kind]
+    if armed:
+        label = key_hint(_CANCEL_CONFIRM_LABEL, f"{STYLE_BOLD} {DUSTY_ROSE}")
+    else:
+        label = Text(choice.label or _FIXED_LABELS[choice.kind], style=style)
+        if choice.needs_input:
+            label.append(f" {_NEEDS_INPUT_MARK}")
+    star = _RECOMMENDED_STAR if starred else " "
+    grid = Table.grid()
+    grid.add_column(width=_MARK_WIDTH, no_wrap=True)
+    grid.add_column(ratio=1)
+    grid.add_row(Text(f" {star} ", style=style), label)
+    if choice.kind is not ChoiceKind.OWN_ANSWER:
+        grid.add_row(Text(" " * _MARK_WIDTH), _consequence(choice, disabled=disabled))
+    return grid

shikiru/dashboard/row_list.py

@@ -0,0 +1,256 @@
+"""A keyboard-driven list of one-line rows shared by the task Events and Relationships views."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, ClassVar
+
+from rich.cells import cell_len
+from rich.text import Text
+from textual import on
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.message import Message
+from textual.widgets import Static
+
+from shikiru.dashboard.details_list_view import ROW_LEAD
+from shikiru.ui.section import BOLD_PRIMARY, grey
+from shikiru.ui.tokens import PRIMARY_TEXT_COLOR
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from rich.console import Console, ConsoleOptions, RenderableType, RenderResult
+    from textual import events
+    from textual.binding import BindingType
+
+_LEAD_GAP = "  "
+_TAIL_GAP = "  "
+_STEP_UP = -1
+_STEP_DOWN = 1
+
+
+@dataclass(frozen=True)
+class RowCells:
+    """One row: a grey lead, the primary text and an optional styled tail that is never cut."""
+
+    lead: str
+    text: str | Text
+    tail: Text | None = None
+    columns: tuple[str | Text, str | Text] | None = None
+    column_width: int = 0
+
+
+@dataclass(frozen=True)
+class _RowLine:
+    cells: RowCells
+    selected: bool
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        if self.cells.columns is not None:
+            yield from self._column_lines(console, options)
+            return
+        line = Text(ROW_LEAD)
+        line.append_text(grey(f"{self.cells.lead}{_LEAD_GAP}" if self.cells.lead else ""))
+        tail = self.cells.tail or Text()
+        gap = _TAIL_GAP if tail else ""
+        body = Text(style=BOLD_PRIMARY if self.selected else PRIMARY_TEXT_COLOR)
+        body.append_text(
+            Text(self.cells.text) if isinstance(self.cells.text, str) else self.cells.text
+        )
+        room = max(options.max_width - line.cell_len - cell_len(gap) - tail.cell_len, 1)
+        body.truncate(room, overflow="ellipsis")
+        line.append_text(body)
+        line.append(gap)
+        line.append_text(tail)
+        line.truncate(max(options.max_width, 1), overflow="ellipsis", pad=True)
+        yield line
+
+    def _column_lines(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        columns = self.cells.columns
+        if columns is None:
+            return
+        label, value = columns
+        label_text = Text(label) if isinstance(label, str) else label.copy()
+        value_text = Text(value) if isinstance(value, str) else value.copy()
+        label_text.pad_right(max(self.cells.column_width - label_text.cell_len, 0))
+        prefix_width = len(ROW_LEAD) + self.cells.column_width + 1
+        value_width = max(options.max_width - prefix_width, 1)
+        lines = value_text.wrap(console, value_width, overflow="fold") or [Text()]
+        for index, value_line in enumerate(lines):
+            line = Text(ROW_LEAD)
+            if index == 0:
+                line.append_text(label_text)
+            else:
+                line.append(" " * self.cells.column_width)
+            line.append(" ")
+            line.append_text(value_line)
+            yield line
+
+
+class _Row(Static):
+    class Chosen(Message):
+        def __init__(self, index: int) -> None:
+            super().__init__()
+            self.index = index
+
+    def __init__(self, index: int, content: RenderableType, *, selected: bool) -> None:
+        super().__init__(content, classes="row-list-row", markup=False)
+        self._index = index
+        self.set_class(selected, "-selected")
+
+    def on_click(self, event: events.Click) -> None:
+        event.stop()
+        self.post_message(self.Chosen(self._index))
+
+
+class RowList(Vertical, can_focus=True):
+    """Rows with a selected background; arrows move, PgUp/PgDn page, End asks for the latest."""
+
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("up", f"move({_STEP_UP})", "Previous", show=False),
+        Binding("down", f"move({_STEP_DOWN})", "Next", show=False),
+        Binding("pageup", "page(0)", "Newer page", show=False),
+        Binding("pagedown", "page(1)", "Older page", show=False),
+        Binding("end", "latest", "Latest", show=False),
+        Binding("enter", "open", "Open", show=False),
+    ]
+    DEFAULT_CSS = """
+    RowList { height: auto; }
+    RowList:focus { background-tint: transparent; }
+    .row-list-row { height: 1; width: 100%; }
+    .row-list-row.-selected { background: $selected-surface; }
+    """
+
+    class _Posted(Message):
+        def __init__(self, row_list: RowList) -> None:
+            super().__init__()
+            self.row_list = row_list
+
+        @property
+        def control(self) -> RowList:
+            return self.row_list
+
+    class Moved(_Posted):
+        """The selection moved to `index`."""
+
+        def __init__(self, row_list: RowList, index: int) -> None:
+            super().__init__(row_list)
+            self.index = index
+
+    class Opened(_Posted):
+        """The row at `index` was opened."""
+
+        def __init__(self, row_list: RowList, index: int) -> None:
+            super().__init__(row_list)
+            self.index = index
+
+    class Paged(_Posted):
+        """The next (`older`) or previous page was asked for, by an arrow past an end or by key."""
+
+        def __init__(self, row_list: RowList, *, older: bool, by_arrow: bool = False) -> None:
+            super().__init__(row_list)
+            self.older = older
+            self.by_arrow = by_arrow
+
+    class Latest(_Posted):
+        """The latest rows were asked for."""
+
+    class Scrolled(_Posted):
+        """The operator scrolled the rows away from the first one."""
+
+    def __init__(self, *, widget_id: str, edge_paging: bool = False) -> None:
+        """Create an empty list; rows arrive through `set_rows`.
+
+        With `edge_paging`, moving past the last or first row asks for the older or newer page.
+        """
+        super().__init__(id=widget_id)
+        self._edge_paging = edge_paging
+        self._cells: tuple[RowCells, ...] = ()
+        self._selected = 0
+        self._empty = ""
+        self._widgets: list[_Row] = []
+
+    @property
+    def selected(self) -> int:
+        """The index of the selected row."""
+        return self._selected
+
+    def set_rows(self, rows: Sequence[RowCells], *, selected: int, empty: str) -> None:
+        """Replace the rows, select `selected` (clamped) and show `empty` when none."""
+        previous = self._selected
+        self._cells = tuple(rows)
+        self._empty = empty
+        self._selected = min(max(selected, 0), max(len(self._cells) - 1, 0))
+        self._paint()
+        if self._selected != previous:
+            self._reveal()
+
+    def action_move(self, step: int) -> None:
+        """Move the selection; at an end, page instead when edge paging is on."""
+        target = self._selected + step
+        if 0 <= target < len(self._cells):
+            self._choose(target)
+        elif self._edge_paging:
+            self.post_message(self.Paged(self, older=step > 0, by_arrow=True))
+
+    def action_page(self, older: int) -> None:
+        """Ask for the older (PgDn) or newer (PgUp) page."""
+        self.post_message(self.Paged(self, older=bool(older)))
+
+    def action_latest(self) -> None:
+        """Ask to jump to the latest rows and follow them."""
+        self.scroll_home(animate=False)
+        self.post_message(self.Latest(self))
+
+    def action_open(self) -> None:
+        """Open the selected row."""
+        if self._cells:
+            self.post_message(self.Opened(self, self._selected))
+
+    def watch_scroll_y(self, old_value: float, new_value: float) -> None:
+        """Tell the owner when the rows are scrolled away from the first one."""
+        super().watch_scroll_y(old_value, new_value)
+        if new_value > 0:
+            self.post_message(self.Scrolled(self))
+
+    @on(_Row.Chosen)
+    def _row_chosen(self, message: _Row.Chosen) -> None:
+        message.stop()
+        self._choose(message.index)
+        self.action_open()
+
+    def _choose(self, index: int) -> None:
+        if index == self._selected:
+            return
+        self._selected = index
+        self._paint()
+        self._reveal()
+        self.post_message(self.Moved(self, index))
+
+    def _lines(self) -> list[RenderableType]:
+        if not self._cells:
+            return [grey(self._empty)]
+        return [_RowLine(cells, index == self._selected) for index, cells in enumerate(self._cells)]
+
+    def _paint(self) -> None:
+        lines = self._lines()
+        highlighted = bool(self._cells)
+        for index, (row, line) in enumerate(zip(self._widgets, lines, strict=False)):
+            row.update(line)
+            row.set_class(highlighted and index == self._selected, "-selected")
+        for row in self._widgets[len(lines) :]:
+            row.remove()
+        del self._widgets[len(lines) :]
+        fresh = [
+            _Row(index, line, selected=highlighted and index == self._selected)
+            for index, line in enumerate(lines)
+            if index >= len(self._widgets)
+        ]
+        self._widgets.extend(fresh)
+        if fresh:
+            self.mount(*fresh)
+
+    def _reveal(self) -> None:
+        if self._selected < len(self._widgets):
+            self._widgets[self._selected].scroll_visible(animate=False)