shikiru-cli 0.2.0__py3-none-any.whl

shikiru/dashboard/detail_fold.py

@@ -0,0 +1,244 @@
+"""Folds of the task details: a header with a live headline above a body that shows when open."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, ClassVar
+
+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 DetailsEntry, entry_renderable
+from shikiru.dashboard.row_list import RowList
+from shikiru.ui.tokens import STEEL_BLUE
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from textual import events
+    from textual.app import ComposeResult
+    from textual.binding import BindingType
+    from textual.widget import Widget
+
+OPEN_MARK = "\N{BLACK DOWN-POINTING SMALL TRIANGLE}"
+CLOSED_MARK = "\N{BLACK RIGHT-POINTING SMALL TRIANGLE}"
+_STEP_UP = -1
+_STEP_DOWN = 1
+_DISPLAY_NONE = "none"
+
+
+class FoldHeader(Static):
+    """One focusable header row; ↑↓ move, Enter opens and enters or folds, Space toggles."""
+
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("up", f"move({_STEP_UP})", "Previous section", show=False),
+        Binding("down", f"move({_STEP_DOWN})", "Next section", show=False),
+        Binding("enter", "enter", "Open or close", show=False),
+        Binding("space", "toggle_open", "Open or close", show=False),
+    ]
+    DEFAULT_CSS = """
+    FoldHeader { height: 1; width: 100%; }
+    FoldHeader:focus { background: $selected-surface; background-tint: transparent; }
+    """
+
+    def __init__(self, fold: DetailFold) -> None:
+        super().__init__("", markup=False)
+        self._fold = fold
+
+    def allow_focus(self) -> bool:
+        """Only the current header is a Tab stop, so the whole list is one stop."""
+        return self._fold.is_current
+
+    def on_focus(self) -> None:
+        self._fold.set_focused(focused=True)
+
+    def on_blur(self) -> None:
+        self._fold.set_focused(focused=False)
+
+    def on_click(self, event: events.Click) -> None:
+        event.stop()
+        self._fold.folds.focus_header(self._fold)
+        self._fold.toggle()
+
+    def action_move(self, step: int) -> None:
+        """Focus the neighbouring header."""
+        self._fold.folds.move(self._fold, step)
+
+    def action_enter(self) -> None:
+        """Fold an open fold; open a closed one and enter its list."""
+        self._fold.toggle()
+
+    def action_toggle_open(self) -> None:
+        """Open or fold the body without leaving the header."""
+        self._fold.set_open(not self._fold.is_open)
+
+
+class DetailFold(Vertical):
+    """A section header with a live headline and a body whose display follows the fold state."""
+
+    DEFAULT_CSS = """
+    DetailFold { height: auto; }
+    DetailFold .fold-body { height: auto; padding: 0 0 1 2; }
+    """
+
+    class Toggled(Message):
+        """The fold opened or closed."""
+
+        def __init__(self, fold: DetailFold) -> None:
+            super().__init__()
+            self.fold = fold
+
+    def __init__(
+        self,
+        view_id: str,
+        title: str,
+        body: Sequence[Widget],
+        *,
+        is_open: bool = False,
+        name_color: str = STEEL_BLUE,
+    ) -> None:
+        """Hold the section's view id, name in its colour, and body."""
+        super().__init__()
+        self.view_id = view_id
+        self.title = title
+        self.headline: str | None = None
+        self.name_color = name_color
+        self.header = FoldHeader(self)
+        self._body = Vertical(*body, classes="fold-body")
+        self._open = is_open
+        self._focused = False
+        self._body.display = self._open
+
+    def compose(self) -> ComposeResult:
+        """Yield the header, then the body."""
+        yield self.header
+        yield self._body
+
+    def on_mount(self) -> None:
+        """Paint the header once it exists."""
+        self.paint()
+
+    @property
+    def folds(self) -> DetailFolds:
+        """The list this fold belongs to: the nearest one above it, so a nested fold has its own."""
+        return next(node for node in self.ancestors if isinstance(node, DetailFolds))
+
+    @property
+    def is_shown(self) -> bool:
+        """Whether the header is on screen: shown itself, inside no hidden or folded fold."""
+        if self.styles.display == _DISPLAY_NONE:
+            return False
+        enclosing = next((node for node in self.ancestors if isinstance(node, DetailFold)), None)
+        return enclosing is None or (enclosing.is_open and enclosing.is_shown)
+
+    @property
+    def is_open(self) -> bool:
+        """Whether the body is shown."""
+        return self._open
+
+    @property
+    def is_current(self) -> bool:
+        """Whether the header is the list's Tab stop."""
+        return self.folds.is_current(self)
+
+    @property
+    def focus_target(self) -> Widget:
+        """The row list inside an open body, otherwise the header."""
+        lists = self._body.query(RowList) if self._open else None
+        return lists.first(RowList) if lists else self.header
+
+    def set_open(self, is_open: bool) -> None:
+        """Show or hide the body and tell the owner when the state changed."""
+        if is_open == self._open:
+            return
+        self._open = is_open
+        self._body.display = is_open
+        self.paint()
+        self.post_message(self.Toggled(self))
+
+    def set_focused(self, *, focused: bool) -> None:
+        """Highlight the header while it has focus."""
+        self._focused = focused
+        self.paint()
+
+    def set_headline(self, headline: str | None) -> None:
+        """Replace the grey right-hand headline."""
+        if headline != self.headline:
+            self.headline = headline
+            self.paint()
+
+    def activate(self) -> None:
+        """Open the fold and move into its list when it has one."""
+        self.set_open(True)
+        self.call_after_refresh(self.folds.focus_fold, self)
+
+    def toggle(self) -> None:
+        """Fold an open fold back to its header; open a closed one and enter its list."""
+        if self._open:
+            self.set_open(False)
+            self.folds.focus_header(self)
+        else:
+            self.activate()
+
+    def paint(self) -> None:
+        """Draw the header: mark, name and headline, highlighted while it has focus."""
+        if not self.header.is_mounted:
+            return
+        mark = OPEN_MARK if self._open else CLOSED_MARK
+        entry = DetailsEntry(
+            self.view_id, f"{mark} {self.title}", self.headline, name_color=self.name_color
+        )
+        self.header.update(entry_renderable(entry, selected=self._focused))
+
+
+class DetailFolds(Vertical):
+    """The list of folds: one Tab stop, ↑↓ between headers."""
+
+    DEFAULT_CSS = "DetailFolds { height: auto; border-top: solid $neutral-border; }"
+
+    def __init__(self, *, widget_id: str) -> None:
+        super().__init__(id=widget_id)
+        self._current: DetailFold | None = None
+
+    @property
+    def all_folds(self) -> list[DetailFold]:
+        """Every fold in display order, shown or not."""
+        return list(self.query(DetailFold))
+
+    @property
+    def visible_folds(self) -> list[DetailFold]:
+        """The folds shown, in display order; a fold inside a closed or hidden one has no header."""
+        return [fold for fold in self.all_folds if fold.is_shown]
+
+    @property
+    def current_fold(self) -> DetailFold:
+        """The fold holding the roving Tab stop: the last one focused, else the first shown."""
+        visible = self.visible_folds
+        if self._current is not None and self._current in visible:
+            return self._current
+        return visible[0]
+
+    def is_current(self, fold: DetailFold) -> bool:
+        """Whether `fold` holds the roving Tab stop; a hidden fold never does."""
+        return fold.is_shown and self.current_fold is fold
+
+    def make_current(self, fold: DetailFold) -> None:
+        """Move the Tab stop to `fold`."""
+        self._current = fold
+
+    def move(self, fold: DetailFold, step: int) -> None:
+        """Focus the header `step` places from `fold`, stopping at both ends."""
+        folds = self.visible_folds
+        target = folds[min(max(folds.index(fold) + step, 0), len(folds) - 1)]
+        self.focus_header(target)
+
+    def focus_header(self, fold: DetailFold) -> None:
+        """Make `fold` the Tab stop and focus its header."""
+        self.make_current(fold)
+        self.screen.set_focus(fold.header)
+
+    def focus_fold(self, fold: DetailFold) -> None:
+        """Focus the row list of an open fold, or its header."""
+        self.make_current(fold)
+        self.screen.set_focus(fold.focus_target)

shikiru/dashboard/detail_hint.py

@@ -0,0 +1,68 @@
+"""The one hint line at the bottom of the task details, following the focused part."""
+
+from __future__ import annotations
+
+from enum import StrEnum
+
+from rich.text import Text
+from textual.widgets import Static
+
+from shikiru.ui.section import BOLD_STEEL, grey
+
+_ARROWS = "\N{UPWARDS ARROW}\N{DOWNWARDS ARROW}"
+_SEPARATOR = " · "
+_BACK = ("Esc", "back")
+_SELECT = (_ARROWS, "select")
+_FOLLOW = ("End", "follow")
+_TASK_WINDOW = ("t", "task window")
+
+
+class HintTarget(StrEnum):
+    """What holds focus inside the task details."""
+
+    HEADER = "header"
+    EVENTS = "events"
+    AGENT = "agent"
+    AGENT_FILTER = "agent_filter"
+    DEPENDENCIES = "dependencies"
+
+
+_HINTS: dict[HintTarget, tuple[tuple[str, str], ...]] = {
+    HintTarget.HEADER: ((_ARROWS, "move"), ("Enter", "open/close")),
+    HintTarget.EVENTS: (_SELECT, _FOLLOW, _BACK),
+    HintTarget.AGENT: (_SELECT, _FOLLOW, ("f", "filter"), _BACK),
+    HintTarget.AGENT_FILTER: (("r", "role"), ("t", "turn"), ("x", "clear"), _BACK),
+    HintTarget.DEPENDENCIES: (_SELECT, ("Enter", "open"), _BACK),
+}
+
+
+def hint_for(target: HintTarget, *, task_window: bool, keys_only: bool) -> Text:
+    """Return the hint for `target`: cyan bold keys, grey labels, only keys in tiny panes.
+
+    Esc is named only inside a list, where it returns to the header.
+    """
+    entries = _HINTS[target] + ((_TASK_WINDOW,) if task_window else ())
+    hint = Text()
+    for index, (key, label) in enumerate(entries):
+        if index:
+            hint.append_text(grey(_SEPARATOR))
+        hint.append(key, style=BOLD_STEEL)
+        if not keys_only:
+            hint.append_text(grey(f" {label}"))
+    return hint
+
+
+class DetailHintBar(Static):
+    """One-row line below the scrolling details; hidden while nothing in them has focus."""
+
+    def __init__(self, *, widget_id: str) -> None:
+        super().__init__("", id=widget_id, markup=False)
+        self.display = False
+        self._hint: Text | None = None
+
+    def show(self, hint: Text | None) -> None:
+        """Show `hint`, or hide the line when there is none."""
+        self.display = hint is not None
+        if hint is not None and hint != self._hint:
+            self.update(hint)
+        self._hint = hint

shikiru/dashboard/details_list_view.py

@@ -0,0 +1,150 @@
+"""Rows of the task detail folds: section names, their data headlines and the row renderable."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import StrEnum
+from typing import TYPE_CHECKING
+
+from rich.cells import cell_len
+from rich.text import Text
+
+from shikiru.dashboard.briefing_view import total_cost_text
+from shikiru.dashboard.fold_bodies import priority_word
+from shikiru.domain.results import ResultOutcome
+from shikiru.domain.tasks import Status
+from shikiru.ui.section import GROUP_SEPARATOR, grey
+from shikiru.ui.tokens import STEEL_BLUE, STYLE_BOLD
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from rich.console import Console, ConsoleOptions, RenderableType, RenderResult
+
+    from shikiru.dashboard.contract import TaskDetailView
+
+ROW_LEAD = "  "
+_HEADLINE_GAP = "  "
+DECISION_OPEN = "question open"
+_PR_WORD = "PR"
+_DECISION_NOUNS = ("decision", "decisions")
+_COMMIT_NOUNS = {True: "commit", False: "commits"}
+_BRANCH_WORD = "branch"
+_PRIORITY_WORD = "priority"
+_DEPENDENCY_NOUNS = ("dependency", "dependencies")
+
+
+class DetailsSection(StrEnum):
+    """The task detail sections, in fold order, named as the headers show them."""
+
+    REQUEST = "Task description"
+    RESULTS = "Results"
+    DECISIONS = "Decisions"
+    EVENTS = "Events"
+    AGENT_ACTIVITY = "Agent activity"
+    USAGE = "Usage"
+    BLOCKERS = "Dependencies"
+    BLOCKER_EVIDENCE = "Evidence"
+    WORKSPACE = "Workspace"
+    SETTINGS = "Settings"
+
+
+@dataclass(frozen=True)
+class DetailsEntry:
+    """One fold header row: what it opens, its name in its colour and its optional grey headline."""
+
+    entry_id: str
+    name: str
+    headline: str | None = None
+    name_color: str = STEEL_BLUE
+
+
+def section_headline(section: DetailsSection, view: TaskDetailView | None) -> str | None:
+    """Return a section's headline from recorded fields, or nothing when it has none."""
+    headline = _HEADLINES.get(section)
+    return headline(view) if headline is not None and view is not None else None
+
+
+@dataclass(frozen=True)
+class _EntryLine:
+    entry: DetailsEntry
+    selected: bool
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        del console
+        entry = self.entry
+        room = max(options.max_width - len(ROW_LEAD), 1)
+        headline = entry.headline or ""
+        if headline and cell_len(entry.name) + cell_len(_HEADLINE_GAP) + cell_len(headline) > room:
+            headline = ""
+        name = Text(entry.name, style=_name_style(entry, selected=self.selected))
+        name.truncate(room - cell_len(headline), overflow="ellipsis", pad=True)
+        line = Text(ROW_LEAD)
+        line.append_text(name)
+        line.append_text(grey(headline))
+        yield line
+
+
+def entry_renderable(entry: DetailsEntry, *, selected: bool) -> RenderableType:
+    """Return one row: the name in its colour (bold when selected), grey headline at the right."""
+    return _EntryLine(entry, selected)
+
+
+def _name_style(entry: DetailsEntry, *, selected: bool) -> str:
+    return f"{STYLE_BOLD} {entry.name_color}" if selected else entry.name_color
+
+
+def _usage_headline(view: TaskDetailView) -> str | None:
+    return total_cost_text(view.sessions)
+
+
+def _workspace_headline(view: TaskDetailView) -> str | None:
+    return f"{_BRANCH_WORD} {view.branch}" if view.branch else None
+
+
+def _settings_headline(view: TaskDetailView) -> str | None:
+    parts = [
+        view.mode or "",
+        f"{priority_word(view.priority)} {_PRIORITY_WORD}" if view.priority is not None else "",
+    ]
+    return GROUP_SEPARATOR.join(part for part in parts if part) or None
+
+
+def _results_headline(view: TaskDetailView) -> str | None:
+    results = view.results
+    if results is None:
+        return None
+    if results.outcome is ResultOutcome.SO_FAR:
+        return ResultOutcome.SO_FAR.value
+    commits = len(results.commits) + results.more_commits
+    pull_request = results.pull_request
+    parts = [
+        f"{commits} {_COMMIT_NOUNS[commits == 1]}" if commits else "",
+        f"{_PR_WORD} #{pull_request.number}"
+        if pull_request is not None and pull_request.number is not None
+        else "",
+    ]
+    return GROUP_SEPARATOR.join(part for part in parts if part) or None
+
+
+def _decisions_headline(view: TaskDetailView) -> str | None:
+    if view.status == Status.ESCALATED.value:
+        return DECISION_OPEN
+    count = len(view.decisions.entries) if view.decisions is not None else 0
+    return f"{count} {_DECISION_NOUNS[count != 1]}" if count else None
+
+
+def _dependencies_headline(view: TaskDetailView) -> str | None:
+    relationships = view.relationships
+    count = relationships.blocking_dependency_count if relationships is not None else 0
+    return f"{count} {_DEPENDENCY_NOUNS[count != 1]}" if count else None
+
+
+_HEADLINES: dict[DetailsSection, Callable[[TaskDetailView], str | None]] = {
+    DetailsSection.RESULTS: _results_headline,
+    DetailsSection.DECISIONS: _decisions_headline,
+    DetailsSection.USAGE: _usage_headline,
+    DetailsSection.WORKSPACE: _workspace_headline,
+    DetailsSection.BLOCKERS: _dependencies_headline,
+    DetailsSection.SETTINGS: _settings_headline,
+}

shikiru/dashboard/diagnostics.py

@@ -0,0 +1,80 @@
+"""Project-level diagnostics from the dashboard's existing observations."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from textual.containers import VerticalGroup
+
+from shikiru.dashboard.diagnostics_sections import engine_section, resources_section
+from shikiru.ui.gated_static import GatedStatic
+from shikiru.ui.screen import widget_is_attached
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from textual.app import ComposeResult
+    from textual.widget import Widget
+    from textual.worker import Worker
+
+    from shikiru.dashboard.contract import DashboardViews, OnChangeRegistration
+
+DIAGNOSTICS_REFRESH_GROUP = "project-diagnostics-refresh"
+RESOURCES_SECTION_ID = "project-diagnostics-resources"
+ENGINE_SECTION_ID = "project-diagnostics-engine"
+
+
+class ProjectDiagnosticsPanel(VerticalGroup):
+    """Show the cached Resources and Engine sections above every configured diagnostics widget."""
+
+    def __init__(
+        self,
+        views: DashboardViews,
+        on_change: OnChangeRegistration,
+        widgets: tuple[Widget, ...],
+    ) -> None:
+        """Use existing dashboard projections and the configured diagnostics widgets in order."""
+        super().__init__(id="project-diagnostics")
+        self._views = views
+        self._on_change = on_change
+        self._widgets = widgets
+        self._resources = GatedStatic(id=RESOURCES_SECTION_ID, markup=False)
+        self._engine = GatedStatic(id=ENGINE_SECTION_ID, markup=False)
+        self._change_worker: Worker[None] | None = None
+        self._unsubscribe_resources: Callable[[], None] | None = None
+
+    def compose(self) -> ComposeResult:
+        """Build the permanent sections, then the configured diagnostics widgets."""
+        yield self._resources
+        yield self._engine
+        yield from self._widgets
+
+    def on_mount(self) -> None:
+        """Render the cached observations and follow the Resources bar's refreshes and commits."""
+        self._refresh()
+        self._unsubscribe_resources = self._views.on_resources_refreshed(self._refresh)
+        self._change_worker = self.run_worker(
+            self._on_change(self._refresh_if_attached),
+            group=DIAGNOSTICS_REFRESH_GROUP,
+        )
+
+    def on_unmount(self) -> None:
+        if self._unsubscribe_resources is not None:
+            self._unsubscribe_resources()
+            self._unsubscribe_resources = None
+        if self._change_worker is not None:
+            self._change_worker.cancel()
+
+    async def _refresh_if_attached(self) -> None:
+        self._refresh()
+
+    def _refresh(self) -> None:
+        if not widget_is_attached(self):
+            return
+        sample = self._views.resource_sample()
+        status = self._views.engine_status()
+        fault_count = len(self._views.engine_faults())
+        self._resources.update_if_changed(resources_section(sample), key=sample)
+        self._engine.update_if_changed(
+            engine_section(status, fault_count), key=(status, fault_count)
+        )