shikiru-cli 0.2.0__py3-none-any.whl

shikiru/dashboard/diagnostics_sections.py

@@ -0,0 +1,186 @@
+"""The permanent Resources and Engine sections of the Project diagnostics popup."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from rich.cells import cell_len
+from rich.console import Group, RenderableType
+from rich.text import Text
+
+from shikiru.dashboard.contract import DiagnosticSampleState
+from shikiru.ui.age import format_duration
+from shikiru.ui.compact import BYTES_PER_GIB, RESOURCE_STATE_UNKNOWN, format_cpu_pct, format_gib
+from shikiru.ui.section import (
+    FAILED_WORD,
+    GROUP_SEPARATOR,
+    UNAVAILABLE_WORD,
+    Row,
+    Section,
+    grey,
+    labelled_rows,
+    number,
+    row_name,
+    state_line,
+)
+from shikiru.ui.tokens import ALERT_COLOR, AMBER, SAGE, SECONDARY_TEXT_COLOR
+
+if TYPE_CHECKING:
+    from rich.console import Console, ConsoleOptions, RenderResult
+
+    from shikiru.dashboard.contract import EngineStatusView, ResourceView
+
+RESOURCES_TITLE = "Resources"
+ENGINE_TITLE = "Engine"
+LABEL_HOST = "Host"
+LABEL_SHIKIRU = "Shikiru"
+LABEL_AGENTS = "Agents"
+LABEL_REFRESH = "Refresh"
+LABEL_STATUS = "Status"
+LABEL_FAULTS = "Faults"
+CPU_WORD = "CPU"
+RAM_WORD = "RAM"
+RSS_WORD = "RSS"
+GIB_UNIT = "GiB"
+RAM_DIVIDER = " / "
+NO_SAMPLE_RECORDED = "no sample recorded"
+PROCESS_TREE_EMPTY = "process tree is empty"
+CPU_RSS_UNAVAILABLE = "CPU/RSS unavailable"
+RAM_UNAVAILABLE = "RAM used/total unavailable"
+STATUS_RUNNING = "Running"
+STATUS_NOT_RUNNING = "Not running"
+UPTIME_PREFIX = "up"
+UPTIME_UNAVAILABLE = "uptime unavailable"
+FAULTS_NONE = "None open"
+FAULTS_OPEN = "open"
+_OBSERVED_STATES = frozenset({DiagnosticSampleState.AVAILABLE, DiagnosticSampleState.EMPTY})
+
+
+def _measure(word: str, value: Text) -> Text:
+    return Text.assemble(grey(f"{word} "), value)
+
+
+def _host_groups(sample: ResourceView) -> tuple[Text, ...]:
+    cpu = _measure(CPU_WORD, number(format_cpu_pct(sample.host_cpu_pct)))
+    used = sample.host_ram_used_bytes
+    total = sample.host_ram_total_bytes
+    if used is None or total is None:
+        return (cpu, grey(RAM_UNAVAILABLE))
+    memory = Text.assemble(
+        number(format_gib(used / BYTES_PER_GIB)),
+        grey(RAM_DIVIDER),
+        number(f"{format_gib(total / BYTES_PER_GIB)} {GIB_UNIT}"),
+    )
+    return (cpu, _measure(RAM_WORD, memory))
+
+
+def _process_groups(
+    cpu_pct: float | None, rss_gb: float | None, *, tree_empty: bool | None
+) -> tuple[Text, ...]:
+    if cpu_pct is None or rss_gb is None:
+        return (grey(PROCESS_TREE_EMPTY if tree_empty else CPU_RSS_UNAVAILABLE),)
+    return (
+        _measure(CPU_WORD, number(format_cpu_pct(cpu_pct))),
+        _measure(RSS_WORD, number(f"{format_gib(rss_gb)} {GIB_UNIT}")),
+    )
+
+
+def _failure(error: str) -> Text:
+    return Text(f"{FAILED_WORD}{GROUP_SEPARATOR}{error}", style=AMBER)
+
+
+@dataclass(frozen=True)
+class _ResourceRows:
+    sample: ResourceView
+    refresh_error: str | None
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        del console
+        sample = self.sample
+        rows: list[Row] = [
+            (row_name(LABEL_HOST), _host_groups(sample)),
+            (
+                row_name(LABEL_SHIKIRU),
+                _process_groups(
+                    sample.shikiru_cpu_pct,
+                    sample.shikiru_rss_gb,
+                    tree_empty=sample.shikiru_process_tree_empty,
+                ),
+            ),
+            (
+                row_name(LABEL_AGENTS),
+                _process_groups(
+                    sample.agents_cpu_pct,
+                    sample.agents_rss_gb,
+                    tree_empty=sample.agents_process_tree_empty,
+                ),
+            ),
+        ]
+        if self.refresh_error is not None:
+            rows.append((grey(LABEL_REFRESH), (_failure(self.refresh_error),)))
+        label_width = max(cell_len(label.plain) for label, _ in rows)
+        yield labelled_rows(rows, options.max_width, label_width)
+
+
+def resources_section(sample: ResourceView | None) -> Section:
+    """Render `sample` as the unruled first Resources section in every state, with no age hint."""
+    if sample is None:
+        return Section(
+            RESOURCES_TITLE,
+            state_line(UNAVAILABLE_WORD, SECONDARY_TEXT_COLOR, NO_SAMPLE_RECORDED),
+            ruled=False,
+        )
+    if sample.state is DiagnosticSampleState.FAILED:
+        return Section(
+            RESOURCES_TITLE, state_line(FAILED_WORD, ALERT_COLOR, sample.error), ruled=False
+        )
+    if sample.state is DiagnosticSampleState.UNAVAILABLE:
+        return Section(
+            RESOURCES_TITLE,
+            state_line(UNAVAILABLE_WORD, SECONDARY_TEXT_COLOR, sample.error),
+            ruled=False,
+        )
+    stale = sample.state is DiagnosticSampleState.STALE
+    rows = _ResourceRows(sample, sample.error if stale else None)
+    body: RenderableType = rows
+    if not stale and sample.state not in _OBSERVED_STATES:
+        body = Group(grey(RESOURCE_STATE_UNKNOWN), rows)
+    return Section(RESOURCES_TITLE, body, ruled=False)
+
+
+def _status_groups(status: EngineStatusView) -> tuple[Text, ...]:
+    if not status.up:
+        return (Text(STATUS_NOT_RUNNING, style=ALERT_COLOR),)
+    uptime = (
+        UPTIME_UNAVAILABLE
+        if status.uptime_seconds is None
+        else f"{UPTIME_PREFIX} {format_duration(status.uptime_seconds)}"
+    )
+    return (Text(STATUS_RUNNING, style=SAGE), grey(uptime))
+
+
+def _faults_groups(fault_count: int) -> tuple[Text, ...]:
+    if not fault_count:
+        return (grey(FAULTS_NONE),)
+    return (Text(f"{fault_count} {FAULTS_OPEN}", style=AMBER),)
+
+
+@dataclass(frozen=True)
+class _EngineRows:
+    status: EngineStatusView
+    fault_count: int
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        del console
+        rows: list[Row] = [
+            (grey(LABEL_STATUS), _status_groups(self.status)),
+            (grey(LABEL_FAULTS), _faults_groups(self.fault_count)),
+        ]
+        label_width = max(cell_len(label.plain) for label, _ in rows)
+        yield labelled_rows(rows, options.max_width, label_width)
+
+
+def engine_section(status: EngineStatusView, fault_count: int) -> Section:
+    """Render engine liveness and the number of open faults as the Engine section."""
+    return Section(ENGINE_TITLE, _EngineRows(status, fault_count))

shikiru/dashboard/evidence_table.py

@@ -0,0 +1,123 @@
+"""A selectable table of evidence entries with a shaded, structured details block under it."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from rich.cells import cell_len
+from rich.console import Group
+from rich.text import Text
+from textual import on
+from textual.containers import Vertical, VerticalScroll
+from textual.widgets import Static
+
+from shikiru.dashboard.row_list import RowCells, RowList
+from shikiru.dashboard.section_rows import TONE_COLORS
+from shikiru.ui.section import BOLD_STEEL, STACKED_BELOW_WIDTH, Row, grey, labelled_rows
+from shikiru.ui.tokens import PRIMARY_TEXT_COLOR, STEEL_BLUE
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from rich.console import Console, ConsoleOptions, RenderResult
+    from textual.app import ComposeResult
+
+    from shikiru.domain.packet_evidence import DetailRow, EvidenceEntry, Part
+
+MAX_LABEL_WIDTH = 19
+DETAIL_STACKED_BELOW_WIDTH = 50
+_KIND_GAP = "  "
+
+
+def part_text(part: Part) -> Text:
+    """Return `part` in its tone colour, or the accent colour."""
+    style = STEEL_BLUE if part.accent else TONE_COLORS[part.tone.value] or PRIMARY_TEXT_COLOR
+    return Text(part.text, style=style)
+
+
+def detail_row(row: DetailRow) -> Row:
+    """Return a details row as a grey label and its toned value."""
+    return grey(row.label), (Text("").join(part_text(part) for part in row.parts),)
+
+
+@dataclass(frozen=True)
+class LabelledRows:
+    """Rows as a capped-width label column and wrapped values; unlabelled rows as plain lines."""
+
+    rows: list[Row]
+    stack_below: int = STACKED_BELOW_WIDTH
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        del console
+        label_width = min(
+            max((cell_len(label.plain) for label, _ in self.rows), default=0), MAX_LABEL_WIDTH
+        )
+        if label_width:
+            yield labelled_rows(self.rows, options.max_width, label_width, self.stack_below)
+        else:
+            yield Group(*(values[0] for _, values in self.rows))
+
+
+class _PageScrollingRowList(RowList):
+    def action_page(self, older: int) -> None:
+        scroller = self.query_ancestor(VerticalScroll)
+        if older:
+            scroller.scroll_page_down(animate=False)
+        else:
+            scroller.scroll_page_up(animate=False)
+
+
+class EvidenceTable(Vertical):
+    """A titled one-line-per-entry table; the selected entry's details show beneath it."""
+
+    DEFAULT_CSS = """
+    EvidenceTable { height: auto; }
+    EvidenceTable RowList { max-height: 8; overflow-y: auto; scrollbar-size-vertical: 1; }
+    EvidenceTable .evidence-detail {
+        height: auto; padding: 0 1; margin: 1 0 0 0;
+        color: $primary-text; background: $detail-surface;
+    }
+    """
+
+    def __init__(self, title: str, entries: Sequence[EvidenceEntry], *, table_id: str) -> None:
+        """Show `title` over one row per entry in `entries`, which must not be empty."""
+        super().__init__()
+        self._title = title
+        self._entries = tuple(entries)
+        self._table_id = table_id
+
+    @property
+    def table(self) -> RowList:
+        """The focusable row list."""
+        return self.query_one(f"#{self._table_id}", RowList)
+
+    def compose(self) -> ComposeResult:
+        yield Static(Text(self._title, style=BOLD_STEEL))
+        yield _PageScrollingRowList(widget_id=self._table_id)
+        yield Static(classes="evidence-detail")
+
+    def on_mount(self) -> None:
+        kind_width = max(cell_len(entry.kind) for entry in self._entries)
+        self.table.set_rows(
+            [self._cells(entry, kind_width) for entry in self._entries], selected=0, empty=""
+        )
+        self._show(0)
+
+    @on(RowList.Moved)
+    def _moved(self, message: RowList.Moved) -> None:
+        message.stop()
+        self._show(message.index)
+
+    @staticmethod
+    def _cells(entry: EvidenceEntry, kind_width: int) -> RowCells:
+        text = Text(entry.kind.ljust(kind_width), style=STEEL_BLUE)
+        text.append(_KIND_GAP)
+        text.append_text(part_text(entry.outcome))
+        return RowCells(entry.lead, text)
+
+    def _show(self, index: int) -> None:
+        rows = [detail_row(row) for row in self._entries[index].details]
+        self.query_one(".evidence-detail", Static).update(
+            LabelledRows(rows, DETAIL_STACKED_BELOW_WIDTH)
+        )

shikiru/dashboard/extra_details.py

@@ -0,0 +1,214 @@
+"""The Extra details popup: the escalation packet's evidence as one scrolling page."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TYPE_CHECKING, ClassVar
+
+from rich.console import Group, RenderableType
+from rich.text import Text
+from textual.containers import Horizontal, Vertical, VerticalScroll
+from textual.screen import ModalScreen
+from textual.widgets import Button, Label, Rule, Static
+
+from shikiru.dashboard.evidence_table import EvidenceTable, LabelledRows
+from shikiru.dashboard.resolution_view import ResolutionLayout, layout_for
+from shikiru.dashboard.row_list import RowList
+from shikiru.dashboard.section_rows import TONE_COLORS, glyph_prefix
+from shikiru.domain.escalation_evidence import EscalationPacket, parse_escalation_packet
+from shikiru.domain.packet_evidence import parse_reports, parse_signals
+from shikiru.domain.timeline_phrases import NO_GLYPH, kind_phrase
+from shikiru.ui.popup import (
+    POPUP_BODY_CLASS,
+    POPUP_CLOSE_CLASS,
+    POPUP_CSS,
+    POPUP_FRAME_CLASS,
+    POPUP_HEADER_CLASS,
+    POPUP_RULE_CLASS,
+    POPUP_TITLE_CLASS,
+    PopupFrame,
+    popup_close_label,
+    prepare_popup,
+)
+from shikiru.ui.section import BOLD_STEEL, GROUP_SEPARATOR, Row, Section, grey
+from shikiru.ui.tokens import AMBER, PRIMARY_TEXT_COLOR
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from textual import events
+    from textual.app import ComposeResult
+    from textual.widget import Widget
+
+EXTRA_DETAILS_CLOSE_BUTTON = "extra-details-close"
+_TITLE = "Extra details"
+_ENTRY_PREFIX = "- "
+_NONE_RECORDED = "(none)"
+_TIME_FORMAT = "%m-%d %H:%M"
+_KIND_SEPARATOR = ": "
+_RESUME_SEPARATOR = " \N{EM DASH} "
+_SESSION_MARKER = " session `"
+_SESSION_ID_CLOSE = "`"
+_ERROR_PREFIX = "Evidence error: "
+_QUESTION_TITLE = "Question"
+_TIMELINE = "Timeline"
+_REPORTS = "Reports"
+_RECENT_SIGNALS = "Recent turn signals"
+_SESSIONS = "Sessions"
+_SIGNALS_TITLE = "Recent signals"
+_REPORTS_TABLE = "extra-details-reports"
+_SIGNALS_TABLE = "extra-details-signals"
+
+
+def _value(text: str) -> tuple[Text, ...]:
+    return (Text(text, style=PRIMARY_TEXT_COLOR),)
+
+
+def _plain_row(line: str) -> Row:
+    return Text(), _value(line)
+
+
+def _timeline_row(line: str) -> Row:
+    entry = line.removeprefix(_ENTRY_PREFIX)
+    stamp, _, message = entry.partition(" ")
+    try:
+        label = datetime.fromisoformat(stamp).strftime(_TIME_FORMAT)
+    except ValueError:
+        return _plain_row(entry)
+    kind, separator, detail = message.partition(_KIND_SEPARATOR)
+    phrase = kind_phrase(kind)
+    if phrase is None:
+        return grey(label), (Text(glyph_prefix(NO_GLYPH) + message, style=PRIMARY_TEXT_COLOR),)
+    text = glyph_prefix(phrase.glyph) + (phrase.text + separator + detail)
+    return grey(label), (Text(text, style=TONE_COLORS[phrase.tone.value] or PRIMARY_TEXT_COLOR),)
+
+
+def _session_row(line: str) -> Row:
+    entry = line.removeprefix(_ENTRY_PREFIX).partition(_RESUME_SEPARATOR)[0]
+    role, _, rest = entry.partition(_KIND_SEPARATOR)
+    agent, marker, session = rest.partition(_SESSION_MARKER)
+    if not marker:
+        return _plain_row(entry)
+    return grey(role), (*_value(agent), grey(session.removesuffix(_SESSION_ID_CLOSE)))
+
+
+def _line_rows(content: str, make: Callable[[str], Row]) -> list[Row]:
+    return [make(line) for line in content.splitlines() if line.strip()]
+
+
+_ROW_SECTIONS: dict[str, tuple[str, Callable[[str], Row]]] = {
+    _TIMELINE: (_TIMELINE, _timeline_row),
+    _SESSIONS: (_SESSIONS, _session_row),
+}
+
+
+def _titled(title: str, body: RenderableType) -> Section:
+    return Section(title, body, ruled=False, title_style=BOLD_STEEL)
+
+
+def _static(title: str, rows: list[Row]) -> Static:
+    return Static(_titled(title, LabelledRows(rows)))
+
+
+def _page_widgets(packet: EscalationPacket) -> list[Widget]:
+    request = packet.agent_request
+    question = request.question if request is not None else packet.question
+    widgets: list[Widget] = []
+    if question:
+        widgets.append(Static(_titled(_QUESTION_TITLE, Text(question, style=PRIMARY_TEXT_COLOR))))
+    for label, content in packet.evidence_sections:
+        if not content or content == _NONE_RECORDED:
+            continue
+        if label in _ROW_SECTIONS:
+            title, make = _ROW_SECTIONS[label]
+            widgets.append(_static(title, _line_rows(content, make)))
+        elif label == _REPORTS and (reports := parse_reports(content)):
+            widgets.append(EvidenceTable(_REPORTS, reports, table_id=_REPORTS_TABLE))
+        elif label == _RECENT_SIGNALS and (signals := parse_signals(content)):
+            widgets.append(EvidenceTable(_SIGNALS_TITLE, signals, table_id=_SIGNALS_TABLE))
+    return widgets
+
+
+def _error_widget(packet: EscalationPacket, packet_text: str) -> Static:
+    error = Text(_ERROR_PREFIX + GROUP_SEPARATOR.join(packet.errors), style=AMBER)
+    return Static(Group(error, Text(""), Text(packet_text, style=PRIMARY_TEXT_COLOR)))
+
+
+class ExtraDetailsScreen(ModalScreen[None]):
+    """Show the evidence of one escalation until the Operator closes it with Esc."""
+
+    BINDINGS: ClassVar[list[tuple[str, str, str]]] = [("escape", "close", "Close")]
+    DEFAULT_CSS = (
+        POPUP_CSS
+        + """
+    #extra-details-frame.compact { margin: 0 1; padding: 0 1; }
+    #extra-details-title { text-wrap: nowrap; text-overflow: ellipsis; }
+    #extra-details-scroll { max-height: 1fr; min-height: 0; }
+    #extra-details-body { height: auto; }
+    #extra-details-body > * { margin-top: 1; }
+    #extra-details-body > :first-child { margin-top: 0; }
+    """
+    )
+
+    def __init__(self, task_id: str, packet_text: str) -> None:
+        """Hold the task id for the title and the packet text to lay out."""
+        super().__init__()
+        prepare_popup(self)
+        self._task_id = task_id
+        self._packet_text = packet_text
+
+    def compose(self) -> ComposeResult:
+        """Lay out the popup frame with its header, rule and scrolling body."""
+        with PopupFrame(widget_id="extra-details-frame", classes=POPUP_FRAME_CLASS):
+            with Horizontal(classes=POPUP_HEADER_CLASS):
+                yield Label(
+                    GROUP_SEPARATOR.join((_TITLE, self._task_id)),
+                    id="extra-details-title",
+                    classes=POPUP_TITLE_CLASS,
+                )
+                yield Button(
+                    popup_close_label(),
+                    id=EXTRA_DETAILS_CLOSE_BUTTON,
+                    classes=POPUP_CLOSE_CLASS,
+                )
+            yield Rule(classes=POPUP_RULE_CLASS)
+            with (
+                VerticalScroll(id="extra-details-scroll", classes=POPUP_BODY_CLASS),
+                Vertical(id="extra-details-body"),
+            ):
+                yield from self._page()
+
+    def _page(self) -> list[Widget]:
+        packet = parse_escalation_packet(self._packet_text)
+        if packet.errors:
+            return [_error_widget(packet, self._packet_text)]
+        return _page_widgets(packet)
+
+    def on_mount(self) -> None:
+        self._fit()
+        tables = self.query(RowList)
+        first = tables.first() if tables else self.query_one("#extra-details-scroll")
+        self.set_focus(first, scroll_visible=False)
+        self.call_after_refresh(self.query_one("#extra-details-frame", PopupFrame).content_ready)
+
+    def on_resize(self, event: events.Resize) -> None:
+        del event
+        if self.is_mounted:
+            self._fit()
+            self.call_after_refresh(
+                self.query_one("#extra-details-frame", PopupFrame).update_preferred_size
+            )
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == EXTRA_DETAILS_CLOSE_BUTTON:
+            self.dismiss()
+
+    def action_close(self) -> None:
+        """Close the popup and return to the Escalations screen."""
+        self.dismiss()
+
+    def _fit(self) -> None:
+        layout = layout_for(self.size.width, self.size.height)
+        self.query_one("#extra-details-frame", PopupFrame).set_class(
+            layout is not ResolutionLayout.WIDE, "compact"
+        )