voidx-cli 3.5.2__py3-none-any.whl

voidx_cli/render_input.py

@@ -0,0 +1,154 @@
+"""Input region rendering helpers."""
+
+from __future__ import annotations
+
+from rich.cells import cell_len
+from rich.text import Text
+
+
+class _InputRendererMixin:
+    def _render_line_width(self, width: int) -> int:
+        return max(width, 1)
+
+    def _input_line_prefix_width(self, row: int) -> int:
+        if row == 0 and self._active_text_prompt is not None:
+            return 0
+        return 2
+
+    def _input_display_text(self, line: str) -> str:
+        if self._active_text_secret:
+            return "*" * cell_len(line)
+        return line
+
+    def _input_display_rows(self, width: int) -> list[int]:
+        render_width = self._render_line_width(width)
+        rows: list[int] = []
+        for row, line in enumerate(self._input_lines):
+            cells = self._input_display_cell_count(row, line)
+            rows.append(max((cells + render_width - 1) // render_width, 1))
+        return rows or [1]
+
+    def _input_display_cell_count(self, row: int, line: str) -> int:
+        display = self._input_display_text(line)
+        cells = self._input_line_prefix_width(row) + cell_len(display)
+        if row == self._cursor_row and not self._active_choice:
+            cursor = min(self._cursor_col, len(line))
+            if self._active_text_secret:
+                cursor_cells = cell_len(line[:cursor])
+                display_cells = len(display)
+            else:
+                cursor_cells = cell_len(display[:cursor])
+                display_cells = cell_len(display)
+            if cursor_cells >= display_cells:
+                cells += 1
+        return cells
+
+    def _render_input_line(
+        self,
+        row: int,
+        line: str,
+        prefix: str,
+        width: int,
+    ) -> list[Text]:
+        segments: list[tuple[str, str]] = []
+        if prefix:
+            segments.append((prefix, "bold white"))
+
+        display = self._input_display_text(line)
+        line_segments = self._input_line_segments(display)
+        if row == self._cursor_row and not self._active_choice:
+            cursor = min(self._cursor_col, len(display))
+            if self._active_text_secret:
+                cursor = min(cell_len(line[: self._cursor_col]), len(display))
+            segments.extend(self._input_line_segments_with_cursor(line_segments, cursor))
+        else:
+            segments.extend(line_segments)
+
+        return self._wrap_input_segments(segments, width)
+
+    def _input_line_segments(self, display: str) -> list[tuple[str, str]]:
+        if self._active_text_secret:
+            return [(display, "white")] if display else []
+        tokens = self._registered_paste_displays()
+        if not tokens:
+            return [(display, "white")] if display else []
+
+        segments: list[tuple[str, str]] = []
+        pos = 0
+        while pos < len(display):
+            match_start = -1
+            match_token = ""
+            for token, _kind in tokens:
+                index = display.find(token, pos)
+                if index == -1:
+                    continue
+                if match_start == -1 or index < match_start:
+                    match_start = index
+                    match_token = token
+            if match_start == -1:
+                segments.append((display[pos:], "white"))
+                break
+            if match_start > pos:
+                segments.append((display[pos:match_start], "white"))
+            segments.append((match_token, "dim cyan"))
+            pos = match_start + len(match_token)
+        return segments
+
+    def _input_line_segments_with_cursor(
+        self,
+        segments: list[tuple[str, str]],
+        cursor: int,
+    ) -> list[tuple[str, str]]:
+        result: list[tuple[str, str]] = []
+        seen = 0
+        inserted = False
+        for text, style in segments:
+            if inserted or cursor >= seen + len(text):
+                result.append((text, style))
+                seen += len(text)
+                continue
+            local = max(cursor - seen, 0)
+            before = text[:local]
+            at = text[local : local + 1] or " "
+            after = text[local + 1 :]
+            if before:
+                result.append((before, style))
+            result.append((at, "reverse white"))
+            if after:
+                result.append((after, style))
+            inserted = True
+            seen += len(text)
+        if not inserted:
+            result.append((" ", "reverse white"))
+        return result
+
+    def _wrap_input_segments(
+        self,
+        segments: list[tuple[str, str]],
+        width: int,
+    ) -> list[Text]:
+        rows: list[Text] = []
+        current = Text()
+        used = 0
+        render_width = self._render_line_width(width)
+
+        for text, style in segments:
+            for char in text:
+                char_width = cell_len(char)
+                if char_width <= 0:
+                    current.append(char, style=style)
+                    continue
+                if used > 0 and used + char_width > render_width:
+                    rows.append(current)
+                    current = Text()
+                    used = 0
+                current.append(char, style=style)
+                used += char_width
+                if used >= render_width:
+                    rows.append(current)
+                    current = Text()
+                    used = 0
+
+        if current.plain or not rows:
+            rows.append(current)
+        return rows

voidx_cli/render_status.py

@@ -0,0 +1,266 @@
+"""Status bar rendering helpers."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from rich.cells import cell_len
+from rich.text import Text
+
+from voidx.llm.usage import format_cache_hit_rate, format_token_count
+from .activity import BUSY_ACTIVITY_STYLE
+from .helpers import (
+    _call_bool,
+    _call_int,
+    _call_status,
+    _clip_cells,
+    _safe_status_value,
+)
+from .state import StatusSummaryCache
+
+
+@dataclass(frozen=True)
+class StatusSegment:
+    kind: str
+    text: str
+
+
+_STATUS_STYLES = {
+    "model": "#6CB6FF",
+    "policy": "#57AB5A",
+    "state": BUSY_ACTIVITY_STYLE,
+    "workflow": "#8BD5FF",
+    "usage": "#56D4DD",
+    "goal": "#C698F0",
+    "separator": "#4B5563",
+}
+_STATUS_VARIANTS = (
+    ("model", "policy", "state", "workflow", "usage", "goal"),
+    ("model", "policy", "state", "workflow", "usage"),
+    ("model", "policy", "state", "workflow", "goal"),
+    ("model", "policy", "state", "usage", "goal"),
+    ("model", "policy", "workflow", "usage", "goal"),
+    ("model", "policy", "state", "workflow"),
+    ("model", "policy", "usage", "goal"),
+    ("model", "policy", "usage"),
+    ("model", "policy", "goal"),
+    ("model", "policy"),
+    ("model",),
+)
+
+_WORKFLOW_RAINBOW = ("#FF6B6B", "#FFD93D", "#6BCB77", "#4D96FF", "#B983FF")
+
+
+class _StatusRendererMixin:
+    def _mark_status_summary_dirty(self) -> None:
+        self._render_state.status_summary_dirty = True
+
+    def _status_summary(self, width: int) -> str:
+        cache = self._render_state.status_summary_cache
+        if (
+            cache is not None
+            and cache.width == width
+            and not self._render_state.status_summary_dirty
+        ):
+            return cache.summary
+
+        snapshot, segments = self._status_segments(include_busy=True)
+        summary, selected = self._select_status_variant(width, segments)
+        self._render_state.status_summary_dirty = False
+        self._render_state.status_summary_cache = StatusSummaryCache(
+            width,
+            snapshot,
+            summary,
+            tuple((segment.kind, segment.text) for segment in selected),
+        )
+        return summary
+
+    def _status_summary_text(self, width: int) -> Text:
+        summary = self._status_summary(width)
+        if not summary:
+            return Text()
+        cache = self._render_state.status_summary_cache
+        selected = ()
+        if cache is not None and cache.width == width and cache.summary == summary:
+            selected = tuple(
+                StatusSegment(kind, text)
+                for kind, text in cache.segments
+            )
+        return self._status_text_from_segments(summary, selected)
+
+    def _status_segments(self, *, include_busy: bool) -> tuple[tuple, tuple[StatusSegment, ...]]:
+        provider = _safe_status_value(getattr(self.status, "provider", ""), "")
+        model = _safe_status_value(getattr(self.status, "model", ""), "")
+        effort = _safe_status_value(getattr(self.status, "reasoning_effort", ""), "")
+        permission = _call_status(getattr(self.status, "permission_label", None), "")
+        sandbox = _call_status(getattr(self.status, "sandbox_label", None), "")
+        approval = _call_status(getattr(self.status, "approval_label", None), "")
+        reviewer = _call_status(getattr(self.status, "approval_reviewer_label", None), "")
+        mode = _call_status(getattr(self.status, "interaction_mode", None), "")
+        plan = _call_bool(getattr(self.status, "plan_mode", None))
+        debug = _call_bool(getattr(self.status, "debug", None))
+        goal_label = _call_status(getattr(self.status, "goal_label", None), "")
+        goal_type = _call_status(getattr(self.status, "goal_type", None), "")
+        goal_awaiting = _call_bool(getattr(self.status, "goal_awaiting_approval", None))
+        active_workflows = _call_workflows(getattr(self.status, "active_workflows", None))
+        stats = getattr(self.status, "usage_stats", None)
+        context_limit = getattr(stats, "context_limit", None) or getattr(self.status, "context_limit", 0)
+        stats_snapshot = (
+            context_limit,
+            getattr(stats, "context_tokens", 0) if stats is not None else 0,
+            getattr(stats, "total_tokens", 0) if stats is not None else 0,
+            getattr(stats, "cache_hit_rate", None) if stats is not None else None,
+        )
+        snapshot = (
+            provider,
+            model,
+            effort,
+            permission,
+            sandbox,
+            approval,
+            reviewer,
+            mode,
+            plan,
+            debug,
+            goal_label,
+            tuple(active_workflows),
+            self._busy,
+            stats_snapshot,
+        )
+        model_text = "/".join(part for part in (provider, model) if part)
+        if effort:
+            model_text = f"{model_text} {effort}"
+
+        policy_parts = [part for part in (permission, sandbox, approval) if part]
+        if reviewer and reviewer != "user":
+            policy_parts.append(reviewer)
+        policy_text = " ".join(policy_parts)
+
+        state_parts = []
+        if mode:
+            state_parts.append(mode)
+        if plan:
+            state_parts.append("plan")
+        if debug:
+            state_parts.append("debug")
+        state_text = " ".join(state_parts)
+
+        usage_text = ""
+        if stats is not None:
+            usage_text = (
+                f"ctx {format_token_count(getattr(stats, 'context_tokens', 0))}/"
+                f"{format_token_count(context_limit)}"
+                f" cache {format_cache_hit_rate(stats)}"
+                f" total {format_token_count(getattr(stats, 'total_tokens', 0))}"
+            )
+
+        goal_text = ""
+        if goal_label:
+            goal_text = goal_label
+
+        workflow_text = ""
+        if active_workflows:
+            workflow_text = ", ".join(active_workflows)
+
+        segments = tuple(
+            segment
+            for segment in (
+                StatusSegment("model", model_text),
+                StatusSegment("policy", policy_text),
+                StatusSegment("state", state_text),
+                StatusSegment("workflow", workflow_text),
+                StatusSegment("usage", usage_text),
+                StatusSegment("goal", goal_text),
+            )
+            if segment.text
+        )
+        return snapshot, segments
+
+    def _select_status_variant(
+        self,
+        width: int,
+        segments: tuple[StatusSegment, ...],
+        *,
+        prefix: StatusSegment | None = None,
+    ) -> tuple[str, tuple[StatusSegment, ...]]:
+        by_kind = {segment.kind: segment for segment in segments}
+        prefix_segments = (prefix,) if prefix is not None and prefix.text else ()
+
+        for variant in _STATUS_VARIANTS:
+            selected = tuple(
+                by_kind[kind]
+                for kind in variant
+                if kind in by_kind
+            )
+            candidate = prefix_segments + selected
+            if not candidate:
+                return "", ()
+            summary = self._status_summary_from_segments(candidate)
+            if cell_len(summary) <= width:
+                return summary, candidate
+
+        fallback = prefix_segments or tuple(
+            segment for segment in segments if segment.kind == "model"
+        )[:1]
+        if not fallback:
+            return "", ()
+        summary = _clip_cells(self._status_summary_from_segments(fallback), width)
+        return summary, ()
+
+    @staticmethod
+    def _status_summary_from_segments(segments: tuple[StatusSegment, ...]) -> str:
+        return "  " + " | ".join(segment.text for segment in segments if segment.text)
+
+    def _status_text_from_segments(
+        self,
+        summary: str,
+        segments: tuple[StatusSegment, ...],
+    ) -> Text:
+        if not summary:
+            return Text()
+        if not segments:
+            return Text(summary, style="#8F9BA8")
+        if summary != self._status_summary_from_segments(segments):
+            return Text(summary, style="#8F9BA8")
+        text = Text("  ")
+        appended = False
+        for segment in segments:
+            if not segment.text:
+                continue
+            if appended:
+                text.append(" | ", style=_STATUS_STYLES["separator"])
+            if segment.kind == "workflow":
+                _append_rainbow(text, segment.text)
+            else:
+                text.append(segment.text, style=_STATUS_STYLES.get(segment.kind, "#8F9BA8"))
+            appended = True
+        return text
+
+
+def _append_rainbow(text: Text, value: str) -> None:
+    color_index = 0
+    for char in value:
+        if char.isspace():
+            text.append(char, style=_STATUS_STYLES["workflow"])
+            continue
+        text.append(char, style=_WORKFLOW_RAINBOW[color_index % len(_WORKFLOW_RAINBOW)])
+        color_index += 1
+
+
+def _call_workflows(func: object) -> list[str]:
+    if not callable(func):
+        return []
+    try:
+        value = func()
+    except Exception:
+        return []
+    if not value:
+        return []
+    if isinstance(value, str):
+        items = [value]
+    else:
+        try:
+            items = list(value)
+        except TypeError:
+            return []
+    return [str(item).strip() for item in items if str(item).strip()]

voidx_cli/render_todo.py

@@ -0,0 +1,79 @@
+"""Pinned todo rendering helpers."""
+
+from __future__ import annotations
+
+from rich.text import Text
+
+from voidx.ui.output.dock import dock
+from .helpers import _clip_cells
+
+
+_TODO_PINNED_MAX_ITEMS = 4
+_TODO_PINNED_ORDER = ("active", "pending", "done")
+_TODO_PINNED_ICONS = {
+    "pending": "○",
+    "active": "◐",
+    "done": "●",
+}
+_TODO_PINNED_STYLES = {
+    "pending": "#8F9BA8",
+    "active": "#7AA2F7",
+    "done": "#A3BE8C",
+}
+
+
+class _TodoRendererMixin:
+    def _pinned_todo_max_rows(self, render_height: int, bottom_fixed_lines: int) -> int:
+        if dock.todo_state() is None:
+            return 0
+        available_rows = render_height - bottom_fixed_lines
+        row_budget = 1 + _TODO_PINNED_MAX_ITEMS
+        return max(1, min(row_budget, available_rows))
+
+    def _pinned_todo_row_count(self, width: int, max_rows: int | None = None) -> int:
+        return len(self._render_pinned_todo_elements(width, max_rows=max_rows))
+
+    def _render_pinned_todo_elements(
+        self,
+        width: int,
+        *,
+        max_rows: int | None = None,
+    ) -> list[Text]:
+        state = dock.todo_state()
+        if state is None:
+            return []
+
+        row_limit = 1 + _TODO_PINNED_MAX_ITEMS if max_rows is None else max_rows
+        if row_limit <= 0:
+            return []
+        elements = [
+            Text(_clip_cells(f"Todo: {state.summary}", width), style="bold #A3BE8C")
+        ]
+        if row_limit <= 1 or not state.items:
+            return elements[:row_limit]
+
+        ordered_items = [
+            item
+            for status in _TODO_PINNED_ORDER
+            for item in state.items
+            if item.status == status
+        ]
+        ordered_items.extend(
+            item for item in state.items if item.status not in _TODO_PINNED_ORDER
+        )
+
+        available_item_rows = row_limit - 1
+        visible_count = available_item_rows
+        if len(ordered_items) > available_item_rows:
+            visible_count = max(available_item_rows - 1, 0)
+        for item in ordered_items[:visible_count]:
+            icon = _TODO_PINNED_ICONS.get(item.status, "○")
+            style = _TODO_PINNED_STYLES.get(item.status, "#8F9BA8")
+            elements.append(Text(_clip_cells(f"  {icon} {item.content}", width), style=style))
+
+        omitted = len(ordered_items) - visible_count
+        if omitted > 0 and len(elements) < row_limit:
+            elements.append(
+                Text(_clip_cells(f"  … {omitted} more todos", width), style="dim")
+            )
+        return elements[:row_limit]

voidx_cli/renderer.py

@@ -0,0 +1,24 @@
+"""Terminal rendering mixin composition."""
+
+from __future__ import annotations
+
+from .overlays import _OverlayRendererMixin
+from .render_activity import _ActivityRendererMixin
+from .render_frame import _FrameRendererMixin
+from .render_input import _InputRendererMixin
+from .render_status import StatusSegment, _StatusRendererMixin
+from .render_todo import _TodoRendererMixin
+
+
+class _TerminalRendererMixin(
+    _FrameRendererMixin,
+    _InputRendererMixin,
+    _ActivityRendererMixin,
+    _TodoRendererMixin,
+    _StatusRendererMixin,
+    _OverlayRendererMixin,
+):
+    """Terminal rendering methods grouped by focused helper mixins."""
+
+
+__all__ = ["StatusSegment", "_TerminalRendererMixin"]