iCode-TUI 0.29.1__py3-none-any.whl

chrys/app/tui/widgets/chat/tool_renderers.py

@@ -0,0 +1,247 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Tool-specific renderers and the factory that selects them.
+
+The factory returns a ToolCall (or compatible widget) based on the tool_name.
+Unknown tools fall back to the base ToolCall (plain text rendering).
+
+Custom renderers must be Widgets and implement the same interface as ToolCall:
+    - ``__init__(call_id, tool_name, args_summary, args=None)``
+    - ``set_complete(result, duration_ms)``
+    - ``set_error(error)``
+    - ``status`` reactive (running/complete/error)
+    - ``call_id``, ``tool_name``, ``result_text`` attributes
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from typing import Any, Protocol
+
+from textual.widget import Widget
+
+from chrys.app.tui.widgets.chat.tool_call import BaseToolCard, ToolCall
+from chrys.foundation.hosted_tools import HostedToolFamily
+from chrys.foundation.i18n import MessageDef, MessageRef, msg
+from chrys.foundation.i18n.formatting import format_message
+from chrys.foundation.tool_kinds import KIND_MCP, KIND_SUB_AGENT
+from chrys.foundation.tool_result_metadata import TOOL_FAILURE_TEXT_SYNTHESIZED_METADATA_KEY
+
+# Registry maps tool names to widget factories that follow the ToolCall protocol.
+_REGISTRY: dict[str, _ToolRendererFactory] = {}
+# Fallback registry maps tool kinds to widget classes.
+_KIND_REGISTRY: dict[str, _ToolRendererFactory] = {}
+_HOSTED_FAMILY_REGISTRY: dict[str, _ToolRendererFactory] = {}
+
+_HOSTED_FAILURE_FALLBACK = msg(
+    "hosted_tools.failure_fallback",
+    fallback="Error: Provider-hosted tool failed.",
+)
+_HOSTED_TITLE_SEARCH = msg("hosted_tools.title_search", fallback="Hosted Search")
+_HOSTED_TITLE_FETCH = msg("hosted_tools.title_fetch", fallback="Hosted Fetch")
+_HOSTED_TITLE_MCP = msg("hosted_tools.title_mcp", fallback="Hosted MCP")
+_HOSTED_TITLE_CODE = msg("hosted_tools.title_code", fallback="Hosted Code")
+_HOSTED_TITLE_IMAGE = msg("hosted_tools.title_image", fallback="Hosted Image")
+_HOSTED_TITLE_SHELL = msg("hosted_tools.title_shell", fallback="Hosted Shell")
+_HOSTED_TITLE_TOOL_DISCOVERY = msg(
+    "hosted_tools.title_tool_discovery",
+    fallback="Hosted Tool Discovery",
+)
+_HOSTED_TITLE_FILE_OPERATION = msg(
+    "hosted_tools.title_file_operation",
+    fallback="Hosted File Operation",
+)
+_HOSTED_TITLE_GENERIC = msg("hosted_tools.title_generic", fallback="Hosted Tool")
+
+_HOSTED_TITLE_BY_FAMILY: dict[str, MessageDef] = {
+    HostedToolFamily.SEARCH: _HOSTED_TITLE_SEARCH,
+    HostedToolFamily.FETCH: _HOSTED_TITLE_FETCH,
+    HostedToolFamily.MCP: _HOSTED_TITLE_MCP,
+    HostedToolFamily.CODE: _HOSTED_TITLE_CODE,
+    HostedToolFamily.IMAGE: _HOSTED_TITLE_IMAGE,
+    HostedToolFamily.SHELL: _HOSTED_TITLE_SHELL,
+    HostedToolFamily.TOOL_DISCOVERY: _HOSTED_TITLE_TOOL_DISCOVERY,
+    HostedToolFamily.FILE_OPERATION: _HOSTED_TITLE_FILE_OPERATION,
+    HostedToolFamily.GENERIC: _HOSTED_TITLE_GENERIC,
+}
+
+# Kinds whose tool names are foreign- or user-chosen (MCP server tools,
+# sub-agent profiles): the chrys-owned name registry must not resolve them —
+# a sub-agent or MCP tool legitimately named e.g. "bash" is not our shell
+# tool. KIND_SHELL stays name-first: its names are chrys-stamped and the kind
+# is deliberately split across renderers (execute vs. list_workspace_dirs).
+_NAME_OPAQUE_KINDS = frozenset({KIND_MCP, KIND_SUB_AGENT})
+
+
+def hosted_failure_display_text(
+    text: str,
+    metadata: Mapping[str, Any] | None,
+    render_message: Callable[[MessageRef], str] = format_message,
+) -> str:
+    """Resolve Chrys-authored hosted failure text while preserving provider text."""
+    if metadata and metadata.get(TOOL_FAILURE_TEXT_SYNTHESIZED_METADATA_KEY) is True:
+        return render_message(_HOSTED_FAILURE_FALLBACK.bind())
+    return text
+
+
+def hosted_family_display_title(
+    family: str,
+    render_message: Callable[[MessageRef], str] = format_message,
+) -> str | None:
+    """Return the English catalog fallback for one known hosted family."""
+    definition = _HOSTED_TITLE_BY_FAMILY.get(family)
+    return render_message(definition.bind()) if definition is not None else None
+
+
+class _ToolRendererFactory(Protocol):
+    """Constructor shared by built-in and structurally compatible renderers."""
+
+    def __call__(
+        self,
+        call_id: str,
+        tool_name: str,
+        args_summary: str = "",
+        args: dict[str, Any] | None = None,
+    ) -> Widget: ...
+
+
+def register_renderer(tool_name: str, cls: _ToolRendererFactory) -> None:
+    """Register a custom renderer class for a tool name."""
+    _REGISTRY[tool_name] = cls
+
+
+def register_kind_renderer(kind: str, cls: _ToolRendererFactory) -> None:
+    """Register a fallback renderer class for a tool kind."""
+    _KIND_REGISTRY[kind] = cls
+
+
+def register_hosted_renderer(family: str, cls: _ToolRendererFactory) -> None:
+    """Register a renderer for one provider-hosted family."""
+    _HOSTED_FAMILY_REGISTRY[family] = cls
+
+
+def register_dynamic_renderer(tool_name: str, cls: _ToolRendererFactory) -> None:
+    """Register a renderer for a runtime-discovered, user-chosen tool name.
+
+    Unlike :func:`register_renderer`, never overwrites an existing
+    registration — a sub-agent profile exposed as e.g. ``bash`` must not
+    hijack the builtin shell renderer for the rest of the process.
+    """
+    _ensure_loaded()
+    _REGISTRY.setdefault(tool_name, cls)
+
+
+def create_tool_widget(
+    call_id: str,
+    tool_name: str,
+    tool_kind: str,
+    args_summary: str = "",
+    args: dict[str, Any] | None = None,
+    *,
+    provider_hosted: bool = False,
+    hosted_family: str = "",
+    provider: str = "",
+    provider_item_type: str = "",
+    provider_status: str = "",
+    provider_call_id: str = "",
+    canonical_status: str = "running",
+    artifacts: list[dict[str, Any]] | None = None,
+) -> Widget:
+    """Create the appropriate widget for a given tool.
+
+    Returns a specialized widget if one is registered for *tool_name*,
+    falls back to *tool_kind* registry, otherwise returns the base ToolCall.
+    """
+    _ensure_loaded()
+    from chrys.app.tui.widgets.chat.renderers.hosted_generic import HostedToolCall
+
+    if provider_hosted:
+        cls = _HOSTED_FAMILY_REGISTRY.get(hosted_family) or HostedToolCall
+    else:
+        named = _REGISTRY.get(tool_name) if tool_kind not in _NAME_OPAQUE_KINDS else None
+        cls = named or _KIND_REGISTRY.get(tool_kind) or ToolCall
+    widget = cls(call_id, tool_name, args_summary, args=args)
+    if isinstance(widget, BaseToolCard):
+        widget.tool_kind = tool_kind
+        widget.configure_hosted(
+            provider_hosted=provider_hosted,
+            hosted_family=hosted_family,
+            provider=provider,
+            provider_item_type=provider_item_type,
+            provider_status=provider_status,
+            provider_call_id=provider_call_id,
+            canonical_status=canonical_status,
+            artifacts=artifacts,
+        )
+    return widget
+
+
+_loaded = False
+
+
+def _ensure_loaded() -> None:
+    """Register built-in renderer classes on first use (lazy)."""
+    global _loaded
+    if _loaded:
+        return
+
+    from chrys.app.tui.widgets.chat.renderers.ask_user import AskUserToolCall
+    from chrys.app.tui.widgets.chat.renderers.execute import ExecuteToolCall
+    from chrys.app.tui.widgets.chat.renderers.file_edit import EditFileToolCall, WriteFileToolCall
+    from chrys.app.tui.widgets.chat.renderers.hosted_code import HostedCodeToolCall
+    from chrys.app.tui.widgets.chat.renderers.hosted_generic import HostedToolCall, HostedToolDiscoveryCall
+    from chrys.app.tui.widgets.chat.renderers.hosted_image import HostedImageToolCall
+    from chrys.app.tui.widgets.chat.renderers.hosted_mcp import HostedMcpToolCall
+    from chrys.app.tui.widgets.chat.renderers.hosted_search import HostedSearchToolCall
+    from chrys.app.tui.widgets.chat.renderers.hosted_shell import HostedShellToolCall
+    from chrys.app.tui.widgets.chat.renderers.read_file import ReadFileToolCall
+    from chrys.app.tui.widgets.chat.renderers.search import GlobToolCall, GrepToolCall
+    from chrys.app.tui.widgets.chat.renderers.skill import SkillToolCall
+    from chrys.app.tui.widgets.chat.renderers.sleep import SleepToolCall
+    from chrys.app.tui.widgets.chat.renderers.sub_agent import SubAgentToolCall
+    from chrys.app.tui.widgets.chat.renderers.todo import TodoToolCall
+    from chrys.foundation.hosted_tools import HostedToolFamily
+    from chrys.foundation.tool_kinds import KIND_ASK_USER, KIND_SHELL, KIND_SLEEP, KIND_SUB_AGENT, KIND_TODO
+    from chrys.service.tools.builtins.shell import SHELL_TOOL_NAMES
+
+    register_hosted_renderer(HostedToolFamily.SEARCH, HostedSearchToolCall)
+    register_hosted_renderer(HostedToolFamily.FETCH, HostedSearchToolCall)
+    register_hosted_renderer(HostedToolFamily.MCP, HostedMcpToolCall)
+    register_hosted_renderer(HostedToolFamily.CODE, HostedCodeToolCall)
+    register_hosted_renderer(HostedToolFamily.IMAGE, HostedImageToolCall)
+    register_hosted_renderer(HostedToolFamily.SHELL, HostedShellToolCall)
+    register_hosted_renderer(HostedToolFamily.TOOL_DISCOVERY, HostedToolDiscoveryCall)
+    register_hosted_renderer(HostedToolFamily.FILE_OPERATION, HostedToolCall)
+    register_hosted_renderer(HostedToolFamily.GENERIC, HostedToolCall)
+
+    register_renderer("ask_user", AskUserToolCall)
+    register_kind_renderer(KIND_ASK_USER, AskUserToolCall)
+
+    # Name registrations cover legacy sessions with no persisted kind; the
+    # kind registration covers any shell name (e.g. an exotic $SHELL basename).
+    for name in SHELL_TOOL_NAMES:
+        register_renderer(name, ExecuteToolCall)
+    register_kind_renderer(KIND_SHELL, ExecuteToolCall)
+    # Shares KIND_SHELL but is a workspace listing, not command execution —
+    # the name pin keeps it off ExecuteToolCall's command/timeout chrome.
+    register_renderer("list_workspace_dirs", ToolCall)
+
+    register_renderer("edit_file", EditFileToolCall)
+    register_renderer("write_file", WriteFileToolCall)
+    register_renderer("read_file", ReadFileToolCall)
+    from chrys.app.tui.widgets.chat.renderers.web import WebToolCall
+
+    register_renderer("web_search", WebToolCall)
+    register_renderer("web_fetch", WebToolCall)
+    register_renderer("grep", GrepToolCall)
+    register_renderer("glob", GlobToolCall)
+    register_renderer("load_skill", SkillToolCall)
+    register_renderer("read_skill_resource", SkillToolCall)
+    register_renderer("run_skill_script", SkillToolCall)
+    register_renderer("sleep", SleepToolCall)
+    register_kind_renderer(KIND_SLEEP, SleepToolCall)
+    register_kind_renderer(KIND_SUB_AGENT, SubAgentToolCall)
+    register_renderer("todo_write", TodoToolCall)
+    register_kind_renderer(KIND_TODO, TodoToolCall)
+
+    _loaded = True

chrys/app/tui/widgets/chat/tool_view_builders.py

@@ -0,0 +1,260 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Reusable widgets and builders for detailed tool-call views."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Callable, Iterable, Sequence
+from contextlib import suppress
+from typing import TYPE_CHECKING, Any
+
+from rich.table import Table
+from rich.text import Text
+from textual.containers import VerticalGroup
+from textual.widget import Widget
+from textual.widgets import Static
+
+from chrys.app.tui.i18n import render_str, widget_localizer
+from chrys.app.tui.util.source_text import sanitize_source_text
+from chrys.app.tui.widgets.chat.image_preview import ImagePreviewGrid, extract_image_previews
+from chrys.app.tui.widgets.markdown import VirtualizedMarkdown
+from chrys.app.tui.widgets.syntax_theme import transparent_syntax
+from chrys.foundation.i18n import DisplayBlock, MessageRef, msg
+from chrys.foundation.i18n.formatting import format_message, sanitize_legacy_scalar
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+
+_MARKDOWN_LANGS = frozenset({"markdown", "md"})
+_PLAIN_LANGS = frozenset({"", "text", "txt"})
+_PARAM_INLINE_MAX = 200
+"""String/JSON values longer than this get their own labeled block, not a table cell."""
+_TOOL_VIEW_IMAGE_MAX_ROWS = 500
+"""Large enough for proportional modal previews while bounding pathological aspect ratios."""
+
+TOOL_VIEW_EMPTY = msg("tui.tool_view.empty", fallback="(empty)")
+TOOL_VIEW_OUTPUT = msg("tui.tool_view.section.output", fallback="Output")
+_TOOL_VIEW_PREPARING_DIFF = msg("tui.tool_view.preparing_diff", fallback="Preparing diff...")
+_TOOL_VIEW_IMAGE_UNAVAILABLE = msg("tui.tool_view.image_unavailable", fallback="(image unavailable)")
+_TOOL_VIEW_DIFF_PREPARE_FAILED = msg(
+    "tui.tool_view.diff_prepare_failed",
+    fallback="Error: failed to prepare diff — {detail}",
+    multiline=True,
+)
+
+
+class ToolViewContent(VerticalGroup):
+    """Container that owns styling for tool-view builder output."""
+
+    DEFAULT_CSS = """
+    ToolViewContent {
+        width: 100%;
+        height: auto;
+    }
+
+    .tool-view-section-title {
+        width: 100%;
+        height: auto;
+        color: $accent;
+        margin: 1 0 0 0;
+    }
+
+    .tool-view-section-title-first {
+        margin: 0;
+    }
+
+    .tool-view-code,
+    .tool-view-text,
+    .tool-view-md,
+    .tool-view-params,
+    .tool-view-image {
+        width: 100%;
+        height: auto;
+        margin: 0 0 1 0;
+    }
+
+    .tool-view-diff {
+        width: 100%;
+        height: auto;
+        margin: 0 0 1 0;
+    }
+
+    .tool-view-diff-placeholder {
+        width: 100%;
+        height: auto;
+        color: $text-muted;
+        text-style: italic;
+    }
+    """
+
+    def __init__(self, widgets: Iterable[Widget]) -> None:
+        super().__init__()
+        self._widgets = list(widgets)
+
+    def compose(self) -> ComposeResult:
+        yield from self._widgets
+
+
+def build_code_view(
+    language: str,
+    text: str,
+    *,
+    dark: bool = True,
+    render_message: Callable[[MessageRef], str] = format_message,
+) -> Widget:
+    """Build a single, untruncated view widget for *text* in *language*.
+
+    ``markdown`` renders via :class:`VirtualizedMarkdown`; plain text renders as
+    wrapped literal text; everything else is syntax-highlighted with a
+    background-transparent, theme-matched Pygments style.
+    """
+    lang = (language or "").strip().lower()
+    body = sanitize_source_text(
+        text or render_message(TOOL_VIEW_EMPTY.bind()), tab_size=8 if lang in _PLAIN_LANGS else 4
+    )
+    if lang in _MARKDOWN_LANGS:
+        return VirtualizedMarkdown(body, classes="tool-view-md")
+    if lang in _PLAIN_LANGS:
+        return Static(Text(body), classes="tool-view-text")
+    return Static(transparent_syntax(body, lang, dark=dark), classes="tool-view-code")
+
+
+def build_output_views(
+    sections: list[tuple[str, str, str]],
+    *,
+    dark: bool = True,
+    render_message: Callable[[MessageRef], str] = format_message,
+) -> list[Widget]:
+    """Turn ``(title, language, text)`` copy sections into view widgets."""
+    widgets: list[Widget] = []
+    multi = len(sections) > 1
+    for title, language, text in sections:
+        if multi:
+            widgets.append(Static(Text(sanitize_legacy_scalar(title), style="bold"), classes="tool-view-section-title"))
+        widgets.append(build_code_view(language, text, dark=dark, render_message=render_message))
+    return widgets
+
+
+class ToolViewImage(Static):
+    """Full-width terminal image preview for the tool detail Output tab."""
+
+    def __init__(self, image_contents: Sequence[Any]) -> None:
+        super().__init__("", classes="tool-view-image")
+        self._previews = extract_image_previews(image_contents)
+
+    def render(self) -> ImagePreviewGrid | Text:
+        if not self._previews:
+            return Text(render_str(widget_localizer(self), _TOOL_VIEW_IMAGE_UNAVAILABLE.bind()), style="dim")
+        max_width = self.content_size.width or self.size.width or 80
+        return ImagePreviewGrid(
+            self._previews,
+            max_width=max_width,
+            max_rows=_TOOL_VIEW_IMAGE_MAX_ROWS,
+            allow_upscale=True,
+        )
+
+    def on_resize(self) -> None:
+        self.refresh(layout=True)
+
+
+def _scalar_text(value: object) -> Text:
+    """Render a scalar parameter value as styled text."""
+    if value is None:
+        return Text("null", style="dim")
+    if isinstance(value, bool):
+        return Text("true" if value else "false")
+    return Text(sanitize_source_text(str(value), tab_size=8))
+
+
+def _param_label(key: str) -> Static:
+    """A bold heading introducing a broken-out parameter value."""
+    return Static(Text(f"{sanitize_legacy_scalar(key)}:", style="bold"), classes="tool-view-section-title")
+
+
+def build_params_view(
+    params: dict[str, Any],
+    *,
+    dark: bool = True,
+    render_message: Callable[[MessageRef], str] = format_message,
+) -> list[Widget]:
+    """Render tool parameters as readable key/value widgets instead of raw JSON."""
+    rows: list[tuple[str, Text]] = []
+    blocks: list[Widget] = []
+    for key, value in params.items():
+        if isinstance(value, str) and ("\n" in value or len(value) > _PARAM_INLINE_MAX):
+            blocks.append(_param_label(key))
+            blocks.append(build_code_view("text", value, dark=dark, render_message=render_message))
+        elif value is None or isinstance(value, (str, int, float, bool)):
+            rows.append((key, _scalar_text(value)))
+        elif isinstance(value, list) and all(not isinstance(item, (dict, list)) for item in value):
+            joined = "\n".join("null" if item is None else str(item) for item in value)
+            rows.append((key, Text(sanitize_source_text(joined or render_message(TOOL_VIEW_EMPTY.bind()), tab_size=8))))
+        else:
+            pretty = json.dumps(value, indent=2, ensure_ascii=False, default=str)
+            if "\n" in pretty or len(pretty) > _PARAM_INLINE_MAX:
+                blocks.append(_param_label(key))
+                blocks.append(build_code_view("json", pretty, dark=dark, render_message=render_message))
+            else:
+                rows.append((key, Text(pretty)))
+
+    widgets: list[Widget] = []
+    if rows:
+        table = Table(box=None, show_header=False, pad_edge=False, padding=(0, 2, 0, 0), expand=False)
+        table.add_column(no_wrap=True)
+        table.add_column(overflow="fold")
+        for key, value_text in rows:
+            table.add_row(Text(sanitize_legacy_scalar(key), style="bold"), value_text)
+        widgets.append(Static(table, classes="tool-view-params"))
+    widgets.extend(blocks)
+    return widgets
+
+
+class ToolViewDiff(VerticalGroup):
+    """Prepare and mount a full unified :class:`DiffView` off the event loop."""
+
+    def __init__(
+        self,
+        path: str,
+        before: str,
+        after: str,
+        *,
+        render_message: Callable[[MessageRef], str] = format_message,
+    ) -> None:
+        super().__init__(classes="tool-view-diff")
+        self._path = path
+        self._before = before
+        self._after = after
+        self._render_message = render_message
+
+    def compose(self) -> ComposeResult:
+        yield Static(
+            self._render_message(_TOOL_VIEW_PREPARING_DIFF.bind()),
+            classes="tool-view-diff-placeholder",
+        )
+
+    def on_mount(self) -> None:
+        self.run_worker(self._prepare_and_mount(), exclusive=True, group="tool-view-diff")
+
+    async def _prepare_and_mount(self) -> None:
+        from chrys.app.tui.widgets.diff_view import DiffView
+
+        dv = DiffView(self._path, self._path, self._before, self._after)
+        dv.split = False
+        dv.auto_height = True
+        try:
+            await dv.prepare()
+        except Exception as exc:
+            with suppress(Exception):
+                self.query_one(".tool-view-diff-placeholder", Static).update(
+                    Text(
+                        render_str(
+                            widget_localizer(self),
+                            _TOOL_VIEW_DIFF_PREPARE_FAILED.bind(detail=DisplayBlock(str(exc))),
+                        )
+                    )
+                )
+            return
+        with suppress(Exception):
+            await self.mount(dv)
+            await self.query_one(".tool-view-diff-placeholder", Static).remove()

chrys/app/tui/widgets/chat/transcript_reader.py

@@ -0,0 +1,57 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Read/copy helpers for mounted chat transcript widgets."""
+
+from __future__ import annotations
+
+from textual.widget import Widget
+
+from chrys.app.tui.widgets.chat.messages import AgentMessage, UserMessage
+from chrys.app.tui.widgets.chat.ports import TranscriptReadPort
+
+
+class TranscriptReader:
+    """Build copy payloads from chat message widgets in document order.
+
+    Replayed entries still waiting to be prepended count too: they sit right
+    above the oldest mounted entry newer than them, and an unmounted entry has
+    no nested messages.
+    """
+
+    def __init__(self, query: TranscriptReadPort) -> None:
+        self._query = query
+
+    def get_agent_responses(self) -> list[tuple[str, str]]:
+        """Return (profile_name, raw_text) of all agent messages in document order."""
+        messages: list[AgentMessage] = []
+        for child in self._document_children():
+            if isinstance(child, AgentMessage):
+                messages.append(child)
+            elif child.is_attached:
+                messages.extend(child.query(AgentMessage))
+        return [(message.profile_name or "Agent", message.text) for message in messages if message.text]
+
+    def get_user_messages(self) -> list[tuple[str, str]]:
+        """Return (role_label, raw_text) of all user messages in document order."""
+        return [
+            ("You", child.text) for child in self._document_children() if isinstance(child, UserMessage) and child.text
+        ]
+
+    def get_all_messages(self) -> list[tuple[str, str]]:
+        """Return (role_label, raw_text) of all user+agent messages in document order."""
+        result: list[tuple[str, str]] = []
+        for child in self._document_children():
+            if isinstance(child, UserMessage) and child.text:
+                result.append(("You", child.text))
+            elif isinstance(child, AgentMessage) and child.text:
+                result.append((child.profile_name or "Agent", child.text))
+        return result
+
+    def _document_children(self) -> list[Widget]:
+        children = self._query.direct_children()
+        pending = self._query.pending_transcript_widgets()
+        if not pending:
+            return children
+        anchor = self._query.transcript_entry_after(pending[-1])
+        at = len(children) if anchor is None else children.index(anchor)
+        return [*children[:at], *pending, *children[at:]]

chrys/app/tui/widgets/checkbox.py

@@ -0,0 +1,24 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Checkbox widgets with terminal-friendly ASCII state markers."""
+
+from __future__ import annotations
+
+from textual.content import Content
+from textual.widgets import Checkbox as TextualCheckbox
+
+CHECKED_MARKER = "[*]"
+UNCHECKED_MARKER = "[ ]"
+
+
+class Checkbox(TextualCheckbox):
+    """A Checkbox that avoids using ``X`` as the visual checked marker."""
+
+    @property
+    def _button(self) -> Content:
+        """Render a stable-width ASCII checkbox marker for the current value."""
+        # Textual exposes static BUTTON_* class attributes, but state-specific
+        # marker changes currently require overriding this private property.
+        # Re-check this implementation when upgrading Textual.
+        marker = CHECKED_MARKER if self.value else UNCHECKED_MARKER
+        return Content.assemble((marker, self.get_visual_style("toggle--button")))

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

@@ -0,0 +1,3 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""App shell widgets — input bar, status bar, header bar, progress indicators."""