shikiru-cli 0.2.0__py3-none-any.whl

shikiru/plugins/widgets/queue_hint.py

@@ -0,0 +1,93 @@
+"""The Home `Tasks` label with its filter and search key hints."""
+
+from __future__ import annotations
+
+from rich.cells import cell_len, set_cell_size
+from rich.text import Text
+
+from shikiru.ui.section import BOLD_STEEL, grey, key_label
+from shikiru.ui.tokens import PRIMARY_TEXT_COLOR
+
+TASKS_LABEL = "Tasks"
+FILTER_KEY = "f"
+SEARCH_KEY = "/"
+MORE_KEY = "m"
+MORE_LABEL = "load more"
+HINT_GAP = "  "
+ELLIPSIS = "\N{HORIZONTAL ELLIPSIS}"
+MIN_SEARCH_CELLS = 3
+LEVEL_FULL = 0
+LEVEL_NAME = 1
+LEVEL_GLYPH = 2
+LEVEL_KEYS = 3
+
+
+def task_list_header(
+    *,
+    name: str,
+    marker: tuple[str, str] | None,
+    search: str,
+    width: int,
+    keys_only: bool,
+) -> Text:
+    """Return `Tasks` and the key hints, shortened until they fit `width` cells.
+
+    A `width` of 0 means the width is not known yet and shows the full hint.
+    """
+    for level in range(LEVEL_KEYS if keys_only else LEVEL_FULL, LEVEL_KEYS):
+        header = _header(level, name, marker, search)
+        if width <= 0 or cell_len(header.plain) <= width:
+            return header
+        clipped = _clip(search, cell_len(header.plain) - width)
+        if clipped is not None:
+            return _header(level, name, marker, clipped)
+    return _header(LEVEL_KEYS, name, marker, search)
+
+
+def load_more_hint(*, keys_only: bool) -> Text:
+    """Return the `m load more` hint, or only the key at tiny heights."""
+    return Text(MORE_KEY, style=BOLD_STEEL) if keys_only else key_label(MORE_KEY, MORE_LABEL)
+
+
+def _clip(search: str, excess: int) -> str | None:
+    keep = cell_len(search) - excess
+    if not search or keep < MIN_SEARCH_CELLS:
+        return None
+    return set_cell_size(search, keep - 1) + ELLIPSIS
+
+
+def _header(level: int, name: str, marker: tuple[str, str] | None, search: str) -> Text:
+    header = Text(TASKS_LABEL)
+    header.append(HINT_GAP)
+    header.append_text(_filter_part(level, name, marker))
+    header.append(HINT_GAP)
+    header.append_text(_search_part(level, search))
+    return header
+
+
+def _filter_part(level: int, name: str, marker: tuple[str, str] | None) -> Text:
+    part = Text(FILTER_KEY, style=BOLD_STEEL)
+    if level == LEVEL_KEYS:
+        return part
+    if level == LEVEL_FULL:
+        part.append_text(grey(" filter:"))
+    part.append(" ")
+    if marker is None:
+        part.append(name, style=PRIMARY_TEXT_COLOR)
+    elif level == LEVEL_GLYPH:
+        part.append(marker[0], style=marker[1])
+    else:
+        part.append(marker[0], style=marker[1])
+        part.append(f" {name}", style=PRIMARY_TEXT_COLOR)
+    return part
+
+
+def _search_part(level: int, search: str) -> Text:
+    part = Text(SEARCH_KEY, style=BOLD_STEEL)
+    if level == LEVEL_FULL:
+        part.append_text(grey(" search"))
+    if search and level <= LEVEL_NAME:
+        if level == LEVEL_FULL:
+            part.append_text(grey(":"))
+        part.append(f" {search}", style=PRIMARY_TEXT_COLOR)
+    return part

shikiru/plugins/widgets/resources.py

@@ -0,0 +1,105 @@
+"""The `resources` widget: host and Shikiru process-tree usage."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from rich.console import Console
+
+from shikiru.dashboard.contract import FOCUS_PROJECT_DIAGNOSTICS_VIEW, WidgetPlacement
+from shikiru.ui.compact import render_resource_metric
+from shikiru.ui.gated_static import GatedStatic
+from shikiru.ui.live_interval import LiveInterval
+from shikiru.ui.screen import widget_is_attached
+
+RESOURCE_ENTER_KEY = "enter"
+
+if TYPE_CHECKING:
+    from rich.text import Text
+    from textual import events
+    from textual.widget import Widget
+
+    from shikiru.dashboard.contract import ResourceView, WidgetContext
+
+
+class ResourcesPanel(GatedStatic):
+    """Show host use and the engine plus every pane process tree."""
+
+    def __init__(self, context: WidgetContext) -> None:
+        """Hold `context`; resource sampling starts on mount."""
+        super().__init__(id="resources")
+        self.can_focus = context.placement is WidgetPlacement.RESOURCES
+        self._widget_context = context
+        self._sample: ResourceView | None = None
+        self._applied_min_height: int | None = None
+        self._interval = LiveInterval(
+            self,
+            lambda: context.settings.current().orchestration.resources.sample_seconds,
+            self._refresh,
+        )
+
+    async def on_mount(self) -> None:
+        """Render and resample resources at the configured cadence."""
+        await self._refresh()
+        if self._widget_context.placement is WidgetPlacement.RESOURCES:
+            self._interval.apply()
+            self.run_worker(self._widget_context.on_change(self._interval.reapply), exclusive=True)
+
+    async def on_click(self, event: events.Click) -> None:
+        if self._widget_context.placement is not WidgetPlacement.RESOURCES:
+            return
+        open_view = self._widget_context.open_contextual_view
+        if open_view is not None:
+            await open_view(FOCUS_PROJECT_DIAGNOSTICS_VIEW)
+            event.stop()
+
+    async def on_key(self, event: events.Key) -> None:
+        if (
+            event.key == RESOURCE_ENTER_KEY
+            and self._widget_context.placement is WidgetPlacement.RESOURCES
+            and self._widget_context.open_contextual_view is not None
+        ):
+            await self._widget_context.open_contextual_view(FOCUS_PROJECT_DIAGNOSTICS_VIEW)
+            event.stop()
+
+    def on_resize(self, event: events.Resize) -> None:
+        del event
+        if self._sample is not None:
+            self._render_sample_at_current_width()
+
+    async def _refresh(self) -> None:
+        if not widget_is_attached(self):
+            return
+        sample = await self._widget_context.views.resources()
+        if not widget_is_attached(self):
+            return
+        self._sample = sample
+        self._render_sample_at_current_width()
+
+    def _render_sample_at_current_width(self) -> None:
+        sample = self._sample
+        if sample is None:
+            return
+        self._update_content(render_resource_metric(sample, width=self.size.width))
+
+    def _update_content(self, content: Text) -> None:
+        self.update_if_changed(content)
+        if self.size.width:
+            rendered_lines = content.wrap(Console(), self.size.width)
+            min_height = len(rendered_lines)
+            if min_height != self._applied_min_height:
+                self._applied_min_height = min_height
+                self.styles.min_height = min_height
+                if self.parent is not None:
+                    self.parent.refresh(layout=True)
+
+
+class ResourcesWidget:
+    """The `resources` dashboard widget plugin."""
+
+    name = "resources"
+    placement = WidgetPlacement.RESOURCES
+
+    def create(self, context: WidgetContext) -> Widget:
+        """Build the resource panel for `context`."""
+        return ResourcesPanel(context)

shikiru/plugins/widgets/strips.py

@@ -0,0 +1,82 @@
+"""The `strips` widget: active tasks as comic-strip panels."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+
+from rich.text import Text
+
+from shikiru.dashboard.contract import WidgetPlacement
+from shikiru.ui.gated_static import GatedStatic
+from shikiru.ui.screen import widget_is_attached, widget_is_current
+from shikiru.ui.strip import STRIP_WIDE_MIN_COLUMNS, TaskStrip
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from textual import events
+    from textual.app import App
+    from textual.widget import Widget
+
+    from shikiru.dashboard.contract import WidgetContext
+    from shikiru.ui.strip import TaskStripData
+
+
+class StripsPanel(GatedStatic):
+    """Renders every active task's strip, in dispatch order, focused task first."""
+
+    def __init__(self, context: WidgetContext) -> None:
+        """Hold `context`; nothing here does I/O until `on_mount`."""
+        super().__init__()
+        self._widget_context = context
+        self._rendered: tuple[list[TaskStripData], int] | None = None
+        self._remove_motion_callback: Callable[[], None] | None = None
+
+    async def on_mount(self) -> None:
+        """Render the current strips, then refresh on every state change."""
+        await self._refresh()
+        self.run_worker(self._widget_context.on_change(self._refresh_if_attached), exclusive=True)
+        self._remove_motion_callback = self._widget_context.on_motion(self._refresh_while_active)
+
+    def on_unmount(self) -> None:
+        if self._remove_motion_callback is not None:
+            self._remove_motion_callback()
+            self._remove_motion_callback = None
+
+    async def _refresh_while_active(self) -> None:
+        if widget_is_current(self) and cast("App[None]", self.app).is_running:
+            await self._refresh(motion=True)
+
+    async def _refresh_if_attached(self) -> None:
+        if widget_is_attached(self):
+            await self._refresh()
+
+    async def on_resize(self, event: events.Resize) -> None:
+        """Re-render at the new width: a narrower pane switches every strip to its one-line form."""
+        del event
+        if widget_is_current(self) and cast("App[None]", self.app).is_running:
+            await self._refresh()
+
+    async def _refresh(self, *, motion: bool = False) -> None:
+        width = self.size.width or STRIP_WIDE_MIN_COLUMNS
+        views = self._widget_context.views.strips()
+        rendering = (views, width)
+        if motion and rendering == self._rendered:
+            return
+        self._rendered = rendering
+        strips = [TaskStrip(data).render(width) for data in views]
+        if not strips:
+            self.update_if_changed("no active tasks")
+            return
+        self.update_if_changed(Text("\n\n").join(strips))
+
+
+class StripsWidget:
+    """The `strips` dashboard widget plugin."""
+
+    name = "strips"
+    placement = WidgetPlacement.WORKFLOW
+
+    def create(self, context: WidgetContext) -> Widget:
+        """Build the `StripsPanel` for `context`."""
+        return StripsPanel(context)

shikiru/plugins/widgets/usage.py

@@ -0,0 +1,176 @@
+"""The `usage` widget: token totals, reported costs and quota windows."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+
+from rich.console import Group, RenderableType
+from rich.text import Text
+
+from shikiru.dashboard.contract import WidgetPlacement
+from shikiru.ui.compact import (
+    USAGE_BY_AGENT_LABEL,
+    USAGE_LIMITS_LABEL,
+    AgentQuotaLimits,
+    AgentUsageRows,
+    ProjectUsageMetric,
+    ProjectUsageTotals,
+)
+from shikiru.ui.gated_static import GatedStatic
+from shikiru.ui.glyphs import GLYPH_QUOTA
+from shikiru.ui.screen import widget_is_attached, widget_is_current
+from shikiru.ui.section import Section
+from shikiru.ui.tokens import AMBER, STYLE_BOLD
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from textual import events
+    from textual.app import App
+    from textual.widget import Widget
+
+    from shikiru.dashboard.contract import (
+        AgentUsageView,
+        QuotaBlockView,
+        RecordedUsageView,
+        WidgetContext,
+    )
+
+ENTER_KEY = "enter"
+NO_USAGE_RECORDED = "No runs or quota windows recorded."
+TASK_USAGE_UNAVAILABLE = "Task usage coverage unavailable"
+
+
+def _banner_texts(blocks: list[QuotaBlockView]) -> list[Text]:
+    return [Text(f"{GLYPH_QUOTA} {block.banner}", style=AMBER) for block in blocks]
+
+
+def _usage_body(
+    totals: RecordedUsageView,
+    agents: list[AgentUsageView],
+    context: WidgetContext,
+    scope: str | None,
+    blocks: list[QuotaBlockView],
+) -> Group:
+    parts: list[RenderableType] = [] if scope is None else [Text(scope, style=STYLE_BOLD)]
+    parts.extend(_banner_texts(blocks))
+    parts.append(ProjectUsageTotals(totals))
+    with_runs = [agent for agent in agents if agent.run_count]
+    with_quotas = [agent for agent in agents if agent.quotas]
+    if with_runs:
+        parts.append(Section(USAGE_BY_AGENT_LABEL, AgentUsageRows(with_runs)))
+    if with_quotas:
+        gauges = context.settings.current().dashboard.gauges
+        limits = AgentQuotaLimits(with_quotas, gauges.quota_warn_pct, gauges.quota_alert_pct)
+        parts.append(Section(USAGE_LIMITS_LABEL, limits))
+    if not agents:
+        parts.append(Text(NO_USAGE_RECORDED))
+    return Group(*parts)
+
+
+class UsagePanel(GatedStatic):
+    """Show token totals and quota gauges for every known agent."""
+
+    def __init__(self, context: WidgetContext) -> None:
+        """Hold `context`; usage refreshes after state changes and for live countdowns."""
+        super().__init__(id="usage")
+        self.can_focus = context.placement is WidgetPlacement.PROJECT_USAGE
+        self._widget_context = context
+        self._rendered: (
+            tuple[RecordedUsageView, list[AgentUsageView], list[QuotaBlockView]] | None
+        ) = None
+        self._home_usage: RecordedUsageView | None = None
+        self._home_blocks: list[QuotaBlockView] = []
+        self._remove_motion_callback: Callable[[], None] | None = None
+
+    async def on_mount(self) -> None:
+        """Render current usage, subscribe to state and tick quota age/countdowns."""
+        await self._refresh()
+        self.run_worker(self._widget_context.on_change(self._refresh_if_attached), exclusive=True)
+        self._remove_motion_callback = self._widget_context.on_motion(self._refresh_on_motion)
+
+    def on_unmount(self) -> None:
+        if self._remove_motion_callback is not None:
+            self._remove_motion_callback()
+            self._remove_motion_callback = None
+
+    def on_resize(self, event: events.Resize) -> None:
+        del event
+        if self._home_usage is not None:
+            self._render_home_usage(self._home_usage, self._home_blocks)
+
+    async def on_click(self, event: events.Click) -> None:
+        if self._widget_context.placement is WidgetPlacement.PROJECT_USAGE:
+            open_view = self._widget_context.open_contextual_view
+            if open_view is not None:
+                await open_view("usage")
+                event.stop()
+
+    async def on_key(self, event: events.Key) -> None:
+        if (
+            event.key == ENTER_KEY
+            and self._widget_context.placement is WidgetPlacement.PROJECT_USAGE
+            and self._widget_context.open_contextual_view is not None
+        ):
+            await self._widget_context.open_contextual_view("usage")
+            event.stop()
+
+    async def _refresh(self, *, motion: bool = False) -> None:
+        if self._widget_context.placement is WidgetPlacement.PROJECT_USAGE:
+            self._home_usage = self._widget_context.views.project_usage()
+            self._home_blocks = self._widget_context.views.quota_blocks()
+            self._render_home_usage(self._home_usage, self._home_blocks)
+            return
+        usage = self._widget_context.views.usage(self._widget_context.focus_task)
+        if self._widget_context.focus_task is None:
+            project_usage = self._widget_context.views.project_usage()
+            blocks = self._widget_context.views.quota_blocks()
+            rendering = (project_usage, usage, blocks)
+            if motion and rendering == self._rendered:
+                return
+            self._rendered = rendering
+            body = _usage_body(project_usage, usage, self._widget_context, None, blocks)
+        else:
+            detail = await self._widget_context.views.task_detail(
+                self._widget_context.focus_task,
+            )
+            if not widget_is_attached(self):
+                return
+            if detail is None or detail.usage is None:
+                body = Group(Text(TASK_USAGE_UNAVAILABLE, style=STYLE_BOLD))
+            else:
+                scope = f"Task {self._widget_context.focus_task}"
+                body = _usage_body(detail.usage, usage, self._widget_context, scope, [])
+        self.update_if_changed(body)
+
+    def _render_home_usage(self, usage: RecordedUsageView, blocks: list[QuotaBlockView]) -> None:
+        metric = ProjectUsageMetric(usage).render_home(width=self.size.width or None)
+        self.update_if_changed(Group(*_banner_texts(blocks), metric))
+
+    async def _refresh_if_active(self, *, motion: bool = False) -> None:
+        if widget_is_current(self) and cast("App[None]", self.app).is_running:
+            await self._refresh(motion=motion)
+
+    async def _refresh_if_attached(self) -> None:
+        if widget_is_attached(self):
+            await self._refresh()
+
+    async def _refresh_on_motion(self) -> None:
+        if self._widget_context.focus_task is None and self._needs_motion_refresh():
+            await self._refresh_if_active(motion=True)
+
+    def _needs_motion_refresh(self) -> bool:
+        if self._widget_context.placement is WidgetPlacement.PROJECT_USAGE:
+            return bool(self._home_blocks)
+        return True
+
+
+class UsageWidget:
+    """The `usage` dashboard widget plugin."""
+
+    name = "usage"
+    placement = WidgetPlacement.PROJECT_USAGE
+
+    def create(self, context: WidgetContext) -> Widget:
+        """Build the usage panel for `context`."""
+        return UsagePanel(context)

shikiru/private.py

@@ -0,0 +1,94 @@
+"""Owner-only creation and tightening of everything Shikiru keeps under `.shikiru/`."""
+
+from __future__ import annotations
+
+import os
+import stat
+from logging.handlers import RotatingFileHandler
+from typing import TYPE_CHECKING
+
+from shikiru.paths import WORKTREES_DIR_NAME
+
+if TYPE_CHECKING:
+    from io import TextIOWrapper
+    from pathlib import Path
+
+PRIVATE_DIR_MODE = 0o700
+PRIVATE_FILE_MODE = 0o600
+_OTHERS_MASK = 0o077
+TEXT_ENCODING = "utf-8"
+_CREATE_WRITE = os.O_WRONLY | os.O_CREAT
+
+
+def make_private_dir(path: Path) -> None:
+    """Create `path` and its missing parents as owner-only directories, racing creators included."""
+    for directory in reversed([path, *path.parents]):
+        if not directory.exists():
+            directory.mkdir(mode=PRIVATE_DIR_MODE, exist_ok=True)
+
+
+def create_private_file(path: Path) -> None:
+    """Create the empty file `path` as owner-only unless it exists; its directory must exist."""
+    os.close(os.open(path, _CREATE_WRITE, PRIVATE_FILE_MODE))
+
+
+def create_private_text(path: Path, text: str) -> None:
+    """Write `text` to the new file `path` as owner-only; raise `FileExistsError` if it exists."""
+    descriptor = os.open(path, _CREATE_WRITE | os.O_EXCL, PRIVATE_FILE_MODE)
+    with os.fdopen(descriptor, "w", encoding=TEXT_ENCODING) as handle:
+        handle.write(text)
+
+
+def write_private_text(path: Path, text: str) -> None:
+    """Write `text` to `path`, creating it owner-only."""
+    descriptor = os.open(path, _CREATE_WRITE | os.O_TRUNC, PRIVATE_FILE_MODE)
+    with os.fdopen(descriptor, "w", encoding=TEXT_ENCODING) as handle:
+        handle.write(text)
+
+
+def append_private_text(path: Path, text: str) -> None:
+    """Append `text` to `path`, creating it owner-only."""
+    descriptor = os.open(path, _CREATE_WRITE | os.O_APPEND, PRIVATE_FILE_MODE)
+    with os.fdopen(descriptor, "a", encoding=TEXT_ENCODING) as handle:
+        handle.write(text)
+
+
+def append_private_bytes(path: Path, content: bytes) -> None:
+    """Append `content` to `path`, creating it owner-only."""
+    descriptor = os.open(path, _CREATE_WRITE | os.O_APPEND, PRIVATE_FILE_MODE)
+    with os.fdopen(descriptor, "ab") as handle:
+        handle.write(content)
+
+
+class PrivateRotatingFileHandler(RotatingFileHandler):
+    """A size-rotated log whose current file is always created owner-only."""
+
+    def _open(self) -> TextIOWrapper:
+        descriptor = os.open(self.baseFilename, _CREATE_WRITE | os.O_APPEND, PRIVATE_FILE_MODE)
+        return os.fdopen(descriptor, "a", encoding=self.encoding)
+
+
+def tighten_state_dir(state_dir: Path) -> list[Path]:
+    """Remove group and other access below `state_dir` and return the paths it changed.
+
+    Task worktrees hold the project's own files, so only the `worktrees/` directory itself is
+    tightened. Symlinks are never followed or changed.
+    """
+    changed: list[Path] = []
+    for directory, subdirectories, names in state_dir.walk():
+        entries = [directory]
+        if directory.name == WORKTREES_DIR_NAME and directory.parent == state_dir:
+            subdirectories.clear()
+        else:
+            entries.extend(directory / name for name in names)
+        changed.extend(entry for entry in entries if not entry.is_symlink() and _restrict(entry))
+    return changed
+
+
+def _restrict(path: Path) -> bool:
+    mode = stat.S_IMODE(path.stat().st_mode)
+    restricted = PRIVATE_DIR_MODE if path.is_dir() else mode & ~_OTHERS_MASK
+    if restricted == mode:
+        return False
+    path.chmod(restricted)
+    return True