iCode-TUI 0.29.1__py3-none-any.whl

chrys/app/tui/screens/dialogs/tool_view.py

@@ -0,0 +1,207 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""ToolDetailModal — full, untruncated tabbed view of a tool call's input/output.
+
+Opened from the per-tool ``view`` affordance next to ``copy``.  Tool renderers
+supply ready-to-mount widgets for the Input and Output tabs; the default
+builders here turn the existing copy payload (``_tool_copy_input`` /
+``_tool_copy_sections``) into syntax-highlighted, markdown, or plain-text views
+so each tool gets a sensible presentation without bespoke code.  Specialized
+renderers (e.g. file edits) override the mixin hooks to inject richer widgets
+such as a full :class:`DiffView`.
+"""
+
+from __future__ import annotations
+
+import contextlib
+from typing import TYPE_CHECKING, ClassVar
+
+from rich.text import Text
+from textual import on
+from textual.containers import ScrollableContainer, VerticalGroup
+from textual.widget import Widget
+from textual.widgets import Static, TabbedContent, TabPane
+
+from chrys.app.tui.binding_display import CLOSE_BINDING, COPY_BINDING, localized_binding
+from chrys.app.tui.clipboard import OSC52_COPY_MAX_BYTES, copy_text_to_clipboards, terminal_clipboard_size
+from chrys.app.tui.copy_messages import COPIED_TITLE
+from chrys.app.tui.i18n import render_str, widget_localizer
+from chrys.app.tui.screens.dialogs.base import BaseDialog
+from chrys.app.tui.widgets.chat.agent_transcript_surface import AgentTranscriptSurface
+from chrys.app.tui.widgets.chat.tool_call import ToolViewRequested
+from chrys.app.tui.widgets.chat.tool_view_builders import ToolViewContent
+from chrys.foundation.i18n import msg
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+
+
+_TITLE_MAX = 72
+
+_COPIED_INPUT = msg("tui.tool_view.copy.input", fallback="Copied input")
+_COPIED_OUTPUT = msg("tui.tool_view.copy.output", fallback="Copied output")
+_COPIED_INPUT_TOO_LARGE = msg(
+    "tui.tool_view.copy.input_too_large",
+    fallback="Copied input (terminal clipboard skipped: payload too large)",
+)
+_COPIED_OUTPUT_TOO_LARGE = msg(
+    "tui.tool_view.copy.output_too_large",
+    fallback="Copied output (terminal clipboard skipped: payload too large)",
+)
+_COPIED_INPUT_UNAVAILABLE = msg(
+    "tui.tool_view.copy.input_unavailable",
+    fallback="Copied input (terminal clipboard unavailable)",
+)
+_COPIED_OUTPUT_UNAVAILABLE = msg(
+    "tui.tool_view.copy.output_unavailable",
+    fallback="Copied output (terminal clipboard unavailable)",
+)
+_COPY_HINT = msg("tui.tool_view.copy_hint", fallback="Press c to copy")
+_INPUT = msg("tui.tool_view.tab.input", fallback="Input")
+_OUTPUT = msg("tui.tool_view.tab.output", fallback="Output")
+_NO_INPUT = msg("tui.tool_view.empty.input", fallback="(no input)")
+_NO_OUTPUT = msg("tui.tool_view.empty.output", fallback="(no output)")
+
+
+def _shorten(value: str, *, limit: int = _TITLE_MAX) -> str:
+    """Return *value* truncated in the middle to fit the modal title."""
+    if len(value) <= limit:
+        return value
+    head = max(8, (limit - 3) // 2)
+    tail = max(8, limit - 3 - head)
+    return f"{value[:head]}...{value[-tail:]}"
+
+
+class ToolDetailModal(BaseDialog[None]):
+    """Modal presenting a tool call's full input and output in two tabs.
+
+    Input/output widgets are selectable; ``BaseDialog`` handles right-click
+    copying for the current Textual screen selection.
+    """
+
+    CSS_PATH = "tool_view.tcss"
+
+    BINDINGS: ClassVar[list] = [
+        localized_binding("escape", "close", CLOSE_BINDING, show=False, priority=True),
+        localized_binding("q", "close", CLOSE_BINDING, show=False),
+        localized_binding("c", "copy", COPY_BINDING, show=False),
+    ]
+
+    def __init__(
+        self,
+        *,
+        title: str,
+        input_widgets: list[Widget],
+        output_widgets: list[Widget],
+        raw_input: str = "",
+        raw_output: str = "",
+        copy_enabled: bool = True,
+        initial_tab: str = "input",
+    ) -> None:
+        super().__init__()
+        self._title = title
+        self._input_widgets = input_widgets
+        self._output_widgets = output_widgets
+        self._raw_input = raw_input
+        self._raw_output = raw_output
+        self._copy_enabled = copy_enabled
+        self._initial = "tool-view-output" if initial_tab == "output" else "tool-view-input"
+
+    @classmethod
+    def from_request(cls, event: ToolViewRequested) -> ToolDetailModal:
+        """Build a modal from the shared tool-card detail request."""
+        return cls(
+            title=event.title,
+            input_widgets=event.input_widgets,
+            output_widgets=event.output_widgets,
+            raw_input=event.raw_input,
+            raw_output=event.raw_output,
+            copy_enabled=event.copy_enabled,
+            initial_tab=event.initial_tab,
+        )
+
+    def compose(self) -> ComposeResult:
+        localizer = widget_localizer(self)
+        with VerticalGroup(id="tool-view-container") as container:
+            container.border_title = Text(_shorten(self._title))
+            if self._copy_enabled:
+                container.border_subtitle = render_str(localizer, _COPY_HINT.bind())
+            # No ``initial=``: that makes ContentTabs validate the active tab during
+            # its own mount, before the per-pane Tab widgets exist, which raised
+            # "No Tab with id ..." intermittently on slow CI. Default to the first
+            # tab and switch (if needed) after the tabs have mounted.
+            with TabbedContent(id="tool-view-tabs"):
+                with (
+                    TabPane(render_str(localizer, _INPUT.bind()), id="tool-view-input"),
+                    ScrollableContainer(classes="tool-view-scroll"),
+                ):
+                    yield ToolViewContent(
+                        self._input_widgets or [Static(Text(render_str(localizer, _NO_INPUT.bind())))]
+                    )
+                with (
+                    TabPane(render_str(localizer, _OUTPUT.bind()), id="tool-view-output"),
+                ):
+                    if len(self._output_widgets) == 1 and isinstance(self._output_widgets[0], AgentTranscriptSurface):
+                        # The transcript is already a high-performance scroll
+                        # owner. Wrapping it in another ScrollableContainer
+                        # makes wheel animation and scrollbar state compete.
+                        yield self._output_widgets[0]
+                    else:
+                        with ScrollableContainer(classes="tool-view-scroll"):
+                            yield ToolViewContent(
+                                self._output_widgets or [Static(Text(render_str(localizer, _NO_OUTPUT.bind())))]
+                            )
+
+    def on_mount(self) -> None:
+        if self._initial != "tool-view-input":
+            self.call_after_refresh(self._activate_initial_tab)
+
+    def _activate_initial_tab(self) -> None:
+        with contextlib.suppress(Exception):
+            self.query_one(TabbedContent).active = self._initial
+
+    @on(ToolViewRequested)
+    def _on_nested_tool_view_requested(self, event: ToolViewRequested) -> None:
+        """Stack a detail modal for a tool rendered inside this modal."""
+        event.stop()
+        self.app.push_screen(ToolDetailModal.from_request(event))
+
+    def action_copy(self) -> None:
+        """Copy the active tab's raw payload (input JSON / output string) to the clipboard."""
+        if not self._copy_enabled:
+            return
+        active = self.query_one(TabbedContent).active
+        if active == "tool-view-output":
+            payload, label = self._raw_output, "output"
+        else:
+            payload, label = self._raw_input, "input"
+        terminal_payload_too_large = terminal_clipboard_size(payload) > OSC52_COPY_MAX_BYTES
+        localizer = widget_localizer(self)
+        copied = _COPIED_OUTPUT if label == "output" else _COPIED_INPUT
+        too_large = _COPIED_OUTPUT_TOO_LARGE if label == "output" else _COPIED_INPUT_TOO_LARGE
+        unavailable = _COPIED_OUTPUT_UNAVAILABLE if label == "output" else _COPIED_INPUT_UNAVAILABLE
+        if copy_text_to_clipboards(self.app, payload, max_terminal_bytes=OSC52_COPY_MAX_BYTES):
+            self.notify(
+                render_str(localizer, copied.bind()),
+                title=render_str(localizer, COPIED_TITLE.bind()),
+                timeout=2,
+                markup=False,
+            )
+        elif terminal_payload_too_large:
+            self.notify(
+                render_str(localizer, too_large.bind()),
+                title=render_str(localizer, COPIED_TITLE.bind()),
+                timeout=3,
+                markup=False,
+            )
+        else:
+            self.notify(
+                render_str(localizer, unavailable.bind()),
+                title=render_str(localizer, COPIED_TITLE.bind()),
+                timeout=3,
+                markup=False,
+            )
+
+    def action_close(self) -> None:
+        """Close the dialog."""
+        self.dismiss(None)

chrys/app/tui/screens/dialogs/tool_view.tcss

@@ -0,0 +1,43 @@
+ToolDetailModal {
+    align: center middle;
+    background: $background 40%;
+}
+
+#tool-view-container {
+    width: 92%;
+    max-width: 120;
+    height: 85%;
+    max-height: 45;
+    border: round $tui-border-primary $border-opacity;
+    border-title-color: $primary;
+    border-title-style: bold;
+    border-subtitle-color: $primary;
+    background: $surface;
+    padding: 0;
+}
+
+#tool-view-tabs {
+    height: 1fr;
+}
+
+#tool-view-tabs ContentSwitcher {
+    height: 1fr;
+}
+
+#tool-view-tabs TabPane {
+    height: 1fr;
+    padding: 0;
+}
+
+.tool-view-scroll {
+    width: 100%;
+    height: 1fr;
+    padding: 0 0 0 1;
+    scrollbar-size: 1 1;
+}
+
+#tool-view-output > AgentTranscriptSurface {
+    width: 100%;
+    height: 1fr;
+    padding: 0 0 0 1;
+}

chrys/app/tui/screens/dialogs/vision_unsupported.py

@@ -0,0 +1,122 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""VisionUnsupportedDialog — modal shown when image input is unavailable."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, ClassVar, Literal
+
+from rich.text import Text
+from textual import on
+from textual.binding import Binding
+from textual.containers import VerticalGroup
+from textual.widgets import Button, Static
+
+from chrys.app.tui.i18n import render_str
+from chrys.app.tui.screens.dialogs.base import BaseDialog
+from chrys.app.tui.widgets import DialogButtonRow, DialogButtonSpec
+from chrys.foundation.i18n import MessageRef, msg
+from chrys.foundation.i18n.formatting import format_message
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+
+    from chrys.app.tui.i18n import LocaleController
+
+USE_IMAGE_PATHS_RESULT = "use_image_paths"
+VisionUnsupportedDialogResult = Literal["use_image_paths"] | None
+
+VISION_UNSUPPORTED_TITLE = msg("tui.vision_unsupported.title", fallback="Image Input Not Available")
+_VISION_USE_PATHS = msg("tui.vision_unsupported.button.use_paths", fallback="Use Paths Instead")
+_VISION_OK = msg("tui.vision_unsupported.button.ok", fallback="OK")
+_DEFAULT_VISION_TITLE = VISION_UNSUPPORTED_TITLE.bind()
+type VisionTitle = MessageRef | str
+
+
+class VisionUnsupportedDialog(BaseDialog[VisionUnsupportedDialogResult]):
+    """Inform the user that image input was not attached or cannot be sent."""
+
+    BINDINGS: ClassVar[list] = [
+        Binding("escape", "dismiss_dialog", show=False, priority=True),
+        Binding("left", "switch_focus", show=False),
+        Binding("right", "switch_focus", show=False),
+    ]
+
+    CSS_PATH = "vision_unsupported.tcss"
+
+    def __init__(
+        self,
+        message: str | Text,
+        title: VisionTitle = _DEFAULT_VISION_TITLE,
+        *,
+        show_path_action: bool = False,
+        locale_controller: LocaleController | None = None,
+    ) -> None:
+        self._locale_controller = locale_controller
+        self._message = message
+        self._title_message = title
+        self._title = self._render_message(title)
+        self._show_path_action = show_path_action
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        with VerticalGroup(id="vision-unsupported-container") as container:
+            container.border_title = Text(self._render_message(self._title_message))
+            with VerticalGroup(id="vision-unsupported-inner"):
+                yield Static(
+                    self._message if isinstance(self._message, Text) else Text(self._message),
+                    id="vision-unsupported-message",
+                )
+            specs: list[DialogButtonSpec] = []
+            if self._show_path_action:
+                specs.append(
+                    DialogButtonSpec(
+                        Text(self._render_message(_VISION_USE_PATHS.bind())),
+                        id="vision-unsupported-use-paths",
+                        variant="warning",
+                    )
+                )
+            specs.append(
+                DialogButtonSpec(
+                    Text(self._render_message(_VISION_OK.bind())),
+                    id="vision-unsupported-ok",
+                    variant="primary",
+                )
+            )
+            yield DialogButtonRow(
+                *specs,
+                id="vision-unsupported-buttons",
+            )
+
+    def on_mount(self) -> None:
+        button_id = "#vision-unsupported-use-paths" if self._show_path_action else "#vision-unsupported-ok"
+        self.query_one(button_id, Button).focus()
+
+    @on(Button.Pressed, "#vision-unsupported-ok")
+    def _on_ok(self, event: Button.Pressed) -> None:
+        event.stop()
+        self.dismiss(None)
+
+    @on(Button.Pressed, "#vision-unsupported-use-paths")
+    def _on_use_paths(self, event: Button.Pressed) -> None:
+        event.stop()
+        self.dismiss(USE_IMAGE_PATHS_RESULT)
+
+    def action_switch_focus(self) -> None:
+        if not self._show_path_action:
+            return
+        use_paths = self.query_one("#vision-unsupported-use-paths", Button)
+        ok = self.query_one("#vision-unsupported-ok", Button)
+        if use_paths.has_focus:
+            ok.focus()
+        else:
+            use_paths.focus()
+
+    def action_dismiss_dialog(self) -> None:
+        self.dismiss(None)
+
+    def _render_message(self, message: VisionTitle) -> str:
+        if isinstance(message, str):
+            return message
+        controller = self._locale_controller
+        return format_message(message) if controller is None else render_str(controller.localizer, message)

chrys/app/tui/screens/dialogs/vision_unsupported.tcss

@@ -0,0 +1,35 @@
+VisionUnsupportedDialog {
+    align: center middle;
+}
+
+#vision-unsupported-container {
+    width: 68;
+    max-width: 90%;
+    height: auto;
+    max-height: 85%;
+    background: $surface;
+    border: round $tui-border-warning $border-opacity;
+    border-title-color: $warning;
+    border-title-style: bold;
+}
+
+#vision-unsupported-inner {
+    width: 100%;
+    height: auto;
+    background: $surface;
+    padding: 1 2;
+}
+
+#vision-unsupported-message {
+    width: 100%;
+    height: auto;
+    max-height: 16;
+    overflow-y: auto;
+}
+
+#vision-unsupported-buttons {
+    dock: bottom;
+    align: center top;
+    height: 3;
+    padding: 0 1;
+}

chrys/app/tui/screens/dialogs/workflow_confirm.py

@@ -0,0 +1,91 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Review workflow metadata and the exact source in separate, independently scrollable tabs."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, ClassVar
+
+from rich.text import Text
+from textual import on
+from textual.containers import Vertical, VerticalScroll
+from textual.content import Content
+from textual.widgets import Button, Static, TabbedContent, TabPane
+
+from chrys.app.tui.binding_display import CANCEL_BINDING, localized_binding
+from chrys.app.tui.screens.dialogs.base import BaseDialog
+from chrys.app.tui.widgets import DialogButtonRow, DialogButtonSpec
+from chrys.app.tui.widgets.workflow import text
+from chrys.app.tui.widgets.workflow.info import INFO_TAB, WorkflowInfo, WorkflowInfoData
+from chrys.app.tui.widgets.workflow.source import WorkflowSourceSyntax
+from chrys.foundation.i18n import MessageDef
+from chrys.orchestration.workflows.preview import WorkflowInspection, WorkflowPreview
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+
+    from chrys.app.tui.i18n import LocaleController
+
+
+class WorkflowConfirmDialog(BaseDialog[bool]):
+    CSS_PATH = "workflow_confirm.tcss"
+    BINDINGS: ClassVar[list] = [localized_binding("escape", "cancel", CANCEL_BINDING, show=False, priority=True)]
+
+    def __init__(
+        self, preview: WorkflowPreview | WorkflowInspection, *, locale_controller: LocaleController | None = None
+    ) -> None:
+        super().__init__()
+        self.preview = preview
+        self.locale_controller = locale_controller
+
+    def finish(self) -> None:
+        self.dismiss_when_topmost(False)
+
+    def _label(self, message: MessageDef) -> str:
+        return text.render(message.bind(), self.locale_controller)
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="workflow-confirm") as container:
+            container.border_title = Text(self._label(text.CONFIRM_TITLE))
+            with TabbedContent(id="workflow-confirm-tabs"):
+                with (
+                    TabPane(Content.from_text(self._label(INFO_TAB), markup=False), id="workflow-confirm-info-tab"),
+                    VerticalScroll(id="workflow-confirm-info-scroll"),
+                ):
+                    yield WorkflowInfo(
+                        WorkflowInfoData.from_inspection(self.preview)
+                        if isinstance(self.preview, WorkflowInspection)
+                        else WorkflowInfoData.from_preview(self.preview),
+                        locale_controller=self.locale_controller,
+                    )
+                with (
+                    TabPane(
+                        Content.from_text(self._label(text.CODE_VIEW), markup=False), id="workflow-confirm-source-tab"
+                    ),
+                    VerticalScroll(id="workflow-confirm-source-scroll"),
+                ):
+                    yield Static(
+                        WorkflowSourceSyntax(self.preview.source.source),
+                        id="workflow-confirm-source",
+                        expand=True,
+                    )
+            yield DialogButtonRow(
+                DialogButtonSpec(Text(self._label(text.CONFIRM)), id="workflow-confirm-yes", variant="warning"),
+                DialogButtonSpec(Text(self._label(text.CANCEL)), id="workflow-confirm-no"),
+            )
+
+    @on(Button.Pressed, "#workflow-confirm-yes")
+    def confirm(self, event: Button.Pressed) -> None:
+        event.stop()
+        self.dismiss(True)
+
+    @on(Button.Pressed, "#workflow-confirm-no")
+    def cancel(self, event: Button.Pressed) -> None:
+        event.stop()
+        self.dismiss(False)
+
+    def action_cancel(self) -> None:
+        self.dismiss(False)
+
+    def _default_dismiss_result(self) -> bool:
+        return False

chrys/app/tui/screens/dialogs/workflow_confirm.tcss

@@ -0,0 +1,17 @@
+WorkflowConfirmDialog {
+    align: center middle;
+    background: $background 60%;
+}
+WorkflowConfirmDialog #workflow-confirm {
+    width: 90%; height: 90%;
+    border: round $tui-border-primary $border-opacity;
+    border-title-color: $primary;
+    background: $surface;
+    padding: 0;
+}
+WorkflowConfirmDialog TabbedContent,
+WorkflowConfirmDialog ContentSwitcher,
+WorkflowConfirmDialog TabPane { height: 1fr; padding: 0; }
+WorkflowConfirmDialog VerticalScroll { padding: 0; scrollbar-size: 1 1; }
+WorkflowConfirmDialog #workflow-confirm-source-scroll { overflow: auto auto; }
+WorkflowConfirmDialog #workflow-confirm-source { width: auto; min-width: 100%; }