iCode-TUI 0.29.1__py3-none-any.whl

chrys/app/tui/widgets/text_area.py

@@ -0,0 +1,258 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""EnhancedTextArea — terminal-friendly TextArea with clipboard + Ctrl+A.
+
+A drop-in replacement for ``textual.widgets.TextArea`` that fixes a
+handful of paper-cuts encountered when running inside real terminals:
+
+* ``Ctrl+A`` selects all (Textual's default ``cursor_line_start`` is
+  rarely what users want when ``Home`` already does the same job).
+* ``Ctrl+Insert`` copies; ``Shift+Insert``, ``Ctrl+Shift+V``, and ``Super+V``
+  paste where terminals forward those keys. VSCode Terminal on Windows
+  intercepts ``Ctrl+V`` before it reaches the child process, and most Linux
+  terminals accept either Ctrl paste variant.
+* ``copy`` / ``cut`` / ``paste`` route through both Textual's app-level
+  clipboard *and* the cross-platform OS clipboard (``pbcopy`` on macOS,
+  Win32 ``SetClipboardData`` on Windows, ``xclip``/``xsel`` on Linux)
+  so the selection survives outside the running app.
+* Right-click copies the current selection before Textual's default
+  mouse-down handling can collapse it.
+* When nothing is selected, ``copy`` falls back to the screen-level
+  selection (so the user can copy a chat message rendered elsewhere on
+  the screen).
+* Pasted text has its line endings normalized to ``\\n``; an optional
+  ``max_paste_tokens`` knob caps the inserted text by token count, with
+  a warning notification on truncation.
+* Textual's inherited ``F5`` / ``F6`` / ``F7`` selection bindings are
+  disabled because they collide with screen-level F-key shortcuts (the
+  main screen uses ``F6`` for the log viewer).
+* ``undo`` / ``redo`` are wrapped to swallow the cursor-out-of-bounds
+  ``ValueError`` / ``IndexError`` Textual occasionally raises after
+  large edits.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from textual.actions import SkipAction
+from textual.strip import Strip
+from textual.widgets import TextArea
+
+from chrys.app.tui.behaviors.right_click_copy import handle_text_area_right_click_copy
+from chrys.app.tui.binding_display import COPY_BINDING, PASTE_BINDING, localized_binding
+from chrys.app.tui.clipboard import copy_text_to_clipboards, paste_text_from_clipboards
+from chrys.app.tui.i18n import render_str, widget_localizer
+from chrys.foundation.i18n import msg
+from chrys.foundation.text.tokenizer import MixedLanguageTokenizer
+
+if TYPE_CHECKING:
+    from textual import events
+    from textual.css.styles import RenderStyles
+
+
+_PASTE_TOKENIZER: MixedLanguageTokenizer | None = None
+"""Lazy-initialized tokenizer shared across all EnhancedTextArea instances."""
+
+MESSAGE_EDITOR_PASTE_MAX_TOKENS = 30_000
+"""Maximum tokens accepted by chat and modal message-editor paste events."""
+
+_PASTE_TRUNCATED_TITLE = msg("tui.editor.title.paste_truncated", fallback="Paste truncated")
+_PASTE_TRUNCATED = msg(
+    "tui.editor.paste_truncated",
+    fallback="Paste truncated: {original_tokens} tokens exceeds the {limit}-token limit.",
+)
+
+
+def _truncate_to_tokens(text: str, max_tokens: int) -> tuple[str, int]:
+    """Truncate *text* so its token count is ``<= max_tokens``.
+
+    Returns ``(truncated_text, original_token_count)``.  Uses a
+    proportional initial cut based on the token/char ratio and refines
+    downwards if the heuristic over-estimates.
+    """
+    global _PASTE_TOKENIZER
+    if _PASTE_TOKENIZER is None:
+        _PASTE_TOKENIZER = MixedLanguageTokenizer()
+    tokens = _PASTE_TOKENIZER.count_tokens(text)
+    if tokens <= max_tokens:
+        return text, tokens
+    limit = max(1, int(len(text) * (max_tokens / tokens)))
+    while limit > 0:
+        candidate = text[:limit]
+        if _PASTE_TOKENIZER.count_tokens(candidate) <= max_tokens:
+            return candidate, tokens
+        limit = int(limit * 0.95)
+    return "", tokens
+
+
+class EnhancedTextArea(TextArea):
+    """``TextArea`` with terminal-friendly clipboard + Ctrl+A select-all.
+
+    Subclass freely to add app-specific behavior (e.g. Enter-submit,
+    history navigation).  Subclasses that override ``_on_key`` should
+    call ``super()._on_key(event)`` so the Ctrl+A handler still fires;
+    do not copy that pattern to handlers whose base implementation
+    leaves Textual's default action enabled.
+    """
+
+    BINDINGS: ClassVar[list] = [
+        localized_binding("ctrl+insert", "copy", COPY_BINDING, show=False),
+        localized_binding("shift+insert", "paste", PASTE_BINDING, show=False),
+        localized_binding("ctrl+shift+v", "paste", PASTE_BINDING, show=False),
+        localized_binding("super+v", "paste", PASTE_BINDING, show=False),
+    ]
+
+    def __init__(
+        self,
+        *args: Any,
+        max_paste_tokens: int | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """Construct an ``EnhancedTextArea``.
+
+        Args:
+            max_paste_tokens: When set, paste events whose tokenized
+                length exceeds this value are truncated and a warning
+                notification is shown.  ``None`` disables the cap.
+            *args, **kwargs: Forwarded to ``TextArea``.
+        """
+        self._max_paste_tokens = max_paste_tokens
+        super().__init__(*args, **kwargs)
+
+    def get_component_styles(self, *names: str) -> RenderStyles:
+        """Resolve component styles, tolerating Textual's mid-recompose race.
+
+        Textual issue #6208 (closed "won't fix"): when a recompose fires
+        during active event processing — e.g. rebuilding a card list from
+        inside a ``Button.Pressed`` handler — this ``TextArea`` can be
+        rendered before the stylesheet has applied its component styles, so
+        a component class the widget *declares* (notably
+        ``text-area--gutter``) is briefly absent from ``_component_styles``
+        and the base call raises ``KeyError``, crashing the render. Render
+        with whatever is materialized this frame; the follow-up refresh
+        reapplies the real styles. A name the class never declares is a
+        genuine error and still propagates.
+        """
+        try:
+            return super().get_component_styles(*names)
+        except KeyError:
+            declared = type(self)._get_component_classes()
+            if any(name not in declared for name in names):
+                raise
+            return super().get_component_styles(*(name for name in names if name in self._component_styles))
+
+    def render_line(self, y: int) -> Strip:
+        """Render safely while Textual is laying out extremely narrow terminals."""
+        if self.content_size.width <= 0:
+            return Strip.blank(0, self.visual_style.rich_style)
+        return super().render_line(y)
+
+    def check_action(self, action: str, parameters: tuple[object, ...]) -> bool | None:
+        if action in {"select_word", "select_line", "select_all"}:
+            return False
+        return super().check_action(action, parameters)
+
+    async def _on_key(self, event: events.Key) -> None:
+        if event.key == "ctrl+a":
+            event.stop()
+            event.prevent_default()
+            self.select_all()
+            return
+        await super()._on_key(event)
+
+    def action_undo(self) -> None:
+        try:
+            super().action_undo()
+        except ValueError, IndexError:
+            self.move_cursor((0, 0))
+
+    def action_redo(self) -> None:
+        try:
+            super().action_redo()
+        except ValueError, IndexError:
+            last_line = self.document.line_count - 1
+            last_col = len(self.document.get_line(last_line))
+            self.move_cursor((last_line, last_col))
+
+    async def _on_paste(self, event: events.Paste) -> None:
+        """Sanitize pasted text and (optionally) cap by token count.
+
+        Calls ``prevent_default`` so Textual's MRO does not also insert
+        the unsanitized text.
+        """
+        event.prevent_default()
+        if self.read_only:
+            return
+        text = self._sanitize_paste_text(event.text)
+        if result := self._replace_via_keyboard(text, *self.selection):
+            self.move_cursor(result.end_location)
+        event.stop()
+
+    def _prepare_paste_text(self, text: str) -> str:
+        """Return text to insert for a paste action."""
+        return text
+
+    def _sanitize_paste_text(self, text: str) -> str:
+        """Normalize pasted text and apply the optional token cap."""
+        text = self._prepare_paste_text(text).replace("\r\n", "\n").replace("\r", "\n")
+        if self._max_paste_tokens is not None:
+            text, original_tokens = _truncate_to_tokens(text, self._max_paste_tokens)
+            if original_tokens > self._max_paste_tokens:
+                localizer = widget_localizer(self)
+                self.notify(
+                    render_str(
+                        localizer,
+                        _PASTE_TRUNCATED.bind(
+                            original_tokens=f"{original_tokens:,}",
+                            limit=f"{self._max_paste_tokens:,}",
+                        ),
+                    ),
+                    title=render_str(localizer, _PASTE_TRUNCATED_TITLE.bind()),
+                    severity="warning",
+                    markup=False,
+                )
+        return text
+
+    def action_copy(self) -> None:
+        """Copy selection to system + app clipboard.
+
+        Falls through to the screen-level selection (e.g. text rendered
+        in chat output) when nothing is selected inside this widget.
+        """
+        selected = self.selected_text
+        if not selected:
+            selected = self.screen.get_selected_text()
+        if not selected:
+            # Match stock TextArea semantics: with nothing to copy anywhere,
+            # defer the key to the next namespace (ultimately the app-level
+            # ctrl+c quit hint).
+            raise SkipAction
+        copy_text_to_clipboards(self.app, selected)
+
+    async def _on_mouse_down(self, event: events.MouseDown) -> None:
+        if handle_text_area_right_click_copy(self, event):
+            # The helper calls prevent_default(), so Textual's MRO dispatch
+            # will not continue into TextArea._on_mouse_down for right-click.
+            return
+        # Let Textual's MRO dispatch run TextArea._on_mouse_down once; a
+        # same-name super() here would run the base mouse handler twice.
+
+    def action_cut(self) -> None:
+        if self.read_only:
+            return
+        selected = self.selected_text
+        if not selected:
+            return
+        start, end = self.selection
+        self._delete_via_keyboard(start, end)
+        copy_text_to_clipboards(self.app, selected)
+
+    def action_paste(self) -> None:
+        """Paste from the freshest clipboard available to this frontend."""
+        if self.read_only:
+            return
+        text = paste_text_from_clipboards(self.app)
+        text = self._sanitize_paste_text(text)
+        if text and (result := self._replace_via_keyboard(text, *self.selection)):
+            self.move_cursor(result.end_location)

chrys/app/tui/widgets/trajectory/__init__.py

@@ -0,0 +1,8 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Trajectory dashboard widgets."""
+
+from chrys.app.tui.widgets.trajectory.panel import DashboardTab, TrajectoryDashboard
+from chrys.app.tui.widgets.trajectory.presentation import ResponsiveTier
+
+__all__ = ["DashboardTab", "ResponsiveTier", "TrajectoryDashboard"]

chrys/app/tui/widgets/trajectory/chartkit.py

@@ -0,0 +1,264 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Small terminal-native chart primitives used by the trajectory dashboard."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping, Sequence
+
+from rich.cells import cell_len, set_cell_size
+from rich.console import Console
+from rich.style import Style
+from rich.text import Text
+
+# One blank cell between each vertical border and the box content.
+SECTION_BOX_PADDING = 1
+# Cells a bordered section spends on chrome: two borders plus padding on both sides.
+SECTION_BOX_CHROME = 2 + 2 * SECTION_BOX_PADDING
+
+
+def section_interior_width(width: int) -> int:
+    """Content cells available inside a bordered section of *width* cells."""
+    return max(1, width - SECTION_BOX_CHROME)
+
+
+def timeline_bar(
+    start: int,
+    end: int,
+    *,
+    origin: int,
+    span: int,
+    width: int,
+    glyph: str = "▮",
+    style: Style | str = "",
+) -> Text:
+    """Render one clipped interval into a fixed-width terminal bar."""
+    usable = max(1, width)
+    if span <= 0 or end <= start:
+        return Text(" " * usable)
+    left = min(usable - 1, max(0, (start - origin) * usable // span))
+    right = min(usable, max(left + 1, (end - origin) * usable // span))
+    return Text.assemble(Text(" " * left), Text(glyph * (right - left), style=style), Text(" " * (usable - right)))
+
+
+def unresolved_bar(width: int, *, style: Style | str = "") -> Text:
+    """Render an explicitly unknown interval without implying a duration."""
+    usable = max(1, width)
+    if usable == 1:
+        return Text("?", style=style)
+    return Text(f"?{'·' * (usable - 2)}?", style=style)
+
+
+def time_ruler(span_ns: int, *, width: int) -> Text:
+    """Render non-overlapping tick labels over a turn-relative nanosecond axis."""
+    usable = max(1, width)
+    cells = [" "] * usable
+    tick_count = 1 if usable < 12 else min(7, usable // 12 + 1)
+    for index in range(tick_count):
+        denominator = max(1, tick_count - 1)
+        position = index * (usable - 1) // denominator
+        value = span_ns * index // denominator
+        label = _axis_duration(value, span_ns)
+        if len(label) > usable:
+            label = label[:usable]
+        start = min(max(0, position - len(label) // 2), usable - len(label))
+        for offset, character in enumerate(label):
+            cells[start + offset] = character
+    return Text("".join(cells))
+
+
+def waterfall_lanes[K](
+    turns: Iterable[tuple[int, Mapping[K, Iterable[tuple[int, int]]]]],
+    *,
+    width: int,
+    lanes: Sequence[tuple[K, str, Style | str]],
+    separator_style: Style | str = "dim",
+) -> dict[K, Text]:
+    """Render concatenated per-turn intervals as mutually exclusive lanes.
+
+    Every terminal cell is painted in at most one lane: the one whose
+    intervals cover the largest share of that cell's time window, ties going
+    to the earlier entry in *lanes*.  A lane therefore never claims an
+    instant another lane owns, and sub-cell slivers cannot bridge a gap the
+    neighbouring lane is drawn in.
+    """
+    keys = [key for key, _, _ in lanes]
+    materialized = [(max(0, span), {key: tuple(intervals.get(key, ())) for key in keys}) for span, intervals in turns]
+    total = sum(span for span, _ in materialized)
+    usable = max(1, width)
+    cells: dict[K, list[str]] = {key: [" "] * usable for key in keys}
+    if total <= 0:
+        return {key: Text("".join(cells[key])) for key in keys}
+    coverage = {key: [0.0] * usable for key in keys}
+    separators: list[int] = []
+    cursor = 0
+    for index, (span, intervals) in enumerate(materialized):
+        turn_left = cursor * usable // total
+        turn_right = (cursor + span) * usable // total
+        turn_width = max(1, turn_right - turn_left)
+        for key in keys:
+            lane_coverage = coverage[key]
+            for start, end in intervals[key]:
+                if end <= start or span <= 0:
+                    continue
+                first = max(0.0, start * turn_width / span)
+                last = min(float(turn_width), end * turn_width / span)
+                cell = int(first)
+                while cell < last and turn_left + cell < usable:
+                    lane_coverage[turn_left + cell] += min(cell + 1, last) - max(cell, first)
+                    cell += 1
+        cursor += span
+        if index < len(materialized) - 1:
+            separators.append(min(usable - 1, cursor * usable // total))
+    for cell in range(usable):
+        winner = max(keys, key=lambda key: coverage[key][cell])
+        if coverage[winner][cell] > 0:
+            cells[winner][cell] = next(glyph for key, glyph, _ in lanes if key == winner)
+    for separator in separators:
+        for key in keys:
+            cells[key][separator] = "┊"
+    rendered: dict[K, Text] = {}
+    for key, glyph, style in lanes:
+        lane = Text("".join(cells[key]))
+        for index, character in enumerate(cells[key]):
+            if character == glyph:
+                lane.stylize(style, index, index + 1)
+            elif character == "┊":
+                lane.stylize(separator_style, index, index + 1)
+        rendered[key] = lane
+    return rendered
+
+
+def coverage_bar(
+    exact: float,
+    estimated: float,
+    missing: float,
+    unresolved: float,
+    *,
+    width: int = 8,
+    exact_style: Style | str = "",
+    estimated_style: Style | str = "",
+    missing_style: Style | str = "",
+    unresolved_style: Style | str = "",
+) -> Text:
+    """Render a closed four-state coverage composition."""
+    usable = max(4, width)
+    shares = (max(0.0, exact), max(0.0, estimated), max(0.0, missing), max(0.0, unresolved))
+    total = sum(shares)
+    if total <= 0:
+        return Text("?" * usable)
+    raw = [share / total * usable for share in shares]
+    counts = [int(value) for value in raw]
+    for index in sorted(range(4), key=lambda item: raw[item] - counts[item], reverse=True)[: usable - sum(counts)]:
+        counts[index] += 1
+    return Text.assemble(
+        Text("█" * counts[0], style=exact_style),
+        Text("▒" * counts[1], style=estimated_style),
+        Text("░" * counts[2], style=missing_style),
+        Text("·" * counts[3], style=unresolved_style),
+    )
+
+
+def percentage_meter(
+    value: float | None,
+    *,
+    width: int = 10,
+    style: Style | str = "",
+    empty_style: Style | str = "dim",
+) -> Text:
+    """Render an htop-style bracket meter with a right-aligned percentage."""
+    usable = max(3, width)
+    if value is None:
+        fill = 0
+        rendered_value = "—"
+    else:
+        bounded = min(100.0, max(0.0, value))
+        fill = round(bounded * usable / 100)
+        rendered_value = f"{value:.1f}%"
+    return Text.assemble(
+        Text("["),
+        Text("█" * fill, style=style),
+        Text("░" * (usable - fill), style=empty_style),
+        Text(f" {rendered_value:>6}"),
+        Text("]"),
+    )
+
+
+def fit_cells(value: str, width: int) -> str:
+    """Crop or pad text to exactly *width* terminal cells."""
+    return set_cell_size(value, max(0, width))
+
+
+def fit_text_cells(value: Text, width: int) -> Text:
+    """Crop styled text with an ellipsis, or pad it, to exactly *width* terminal cells."""
+    if width <= 0:
+        return Text()
+    fitted = value.copy()
+    fitted.truncate(width, overflow="ellipsis", pad=True)
+    return fitted
+
+
+def bordered_section(
+    title: str | Text,
+    lines: Iterable[Text],
+    *,
+    width: int,
+    console: Console,
+    border_style: Style | str = "dim",
+    title_style: Style | str = "bold",
+    content_height: int | None = None,
+) -> list[Text]:
+    """Wrap content in a fixed-cell-width box with an inline title."""
+    usable = max(6, width)
+    interior_width = usable - SECTION_BOX_CHROME
+    padding = " " * SECTION_BOX_PADDING
+    rendered_title = title.copy() if isinstance(title, Text) else Text(title)
+    rendered_title.stylize_before(title_style)
+    rendered_title.truncate(usable - 6, overflow="ellipsis")
+    top_fill = usable - cell_len(rendered_title.plain) - 5
+    top = Text.assemble(
+        Text("┌─ ", style=border_style),
+        rendered_title,
+        Text(" "),
+        Text(f"{'─' * top_fill}┐", style=border_style),
+    )
+    wrapped: list[Text] = []
+    for line in lines:
+        wrapped.extend(list(line.wrap(console, interior_width, overflow="fold")) or [Text()])
+    target_height = max(len(wrapped), content_height or 0)
+    wrapped.extend(Text() for _ in range(target_height - len(wrapped)))
+    body = [
+        Text.assemble(
+            Text("│", style=border_style),
+            Text(padding),
+            fit_text_cells(line, interior_width),
+            Text(padding),
+            Text("│", style=border_style),
+        )
+        for line in wrapped
+    ]
+    bottom = Text(f"└{'─' * (usable - 2)}┘", style=border_style)
+    return [top, *body, bottom]
+
+
+def _axis_duration(value_ns: int, span_ns: int) -> str:
+    """Compact tick label whose unit follows the magnitude: ms → s → m → h.
+
+    The origin borrows the axis span's unit so ``0s`` sits next to ``1m46s``
+    while a sub-second axis still reads ``0ms … 800ms``.
+    """
+    seconds = value_ns / 1_000_000_000
+    if value_ns <= 0:
+        return "0ms" if span_ns < 1_000_000_000 else "0s"
+    if seconds < 1:
+        return f"{seconds * 1000:.0f}ms"
+    if seconds < 10:
+        return f"{seconds:.1f}s"
+    whole_seconds = round(seconds)
+    if whole_seconds < 60:
+        return f"{whole_seconds}s"
+    minutes, remainder = divmod(whole_seconds, 60)
+    if minutes < 60:
+        return f"{minutes}m{remainder:02d}s"
+    hours, minutes = divmod(minutes, 60)
+    return f"{hours}h{minutes:02d}m"