iCode-TUI 0.29.1__py3-none-any.whl

chrys/app/tui/widgets/workflow/source.py

@@ -0,0 +1,65 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Literal workflow source display, independent of the bytes trusted and executed."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from rich.segment import Segment
+from rich.syntax import Syntax
+
+from chrys.app.tui.util.source_text import sanitize_source_text
+
+if TYPE_CHECKING:
+    from rich.console import Console, ConsoleOptions, RenderResult
+
+type _RenderKey = tuple[int, bool | None, bool, bool, str | None]
+
+# One layout pass renders the view at two widths (with and without the vertical
+# scrollbar of the scroll view around it); older widths are rendered again.
+_RENDERED_WIDTHS = 2
+
+
+class WorkflowSourceSyntax(Syntax):
+    """Line-numbered, non-wrapping view of workflow source that is lexed once per render width.
+
+    Textual renders a Rich renderable again for every height query and every paint,
+    and each ``Syntax`` render re-lexes the whole file. The code and every render
+    setting are fixed at construction, and with them ``Syntax`` output depends only
+    on the option and console fields in the render key, so the segments rendered
+    for a recent key are replayed instead.
+    """
+
+    def __init__(self, source: bytes) -> None:
+        # Normalize source whitespace before replacing terminal control characters.
+        super().__init__(
+            sanitize_source_text(source.decode("utf-8", errors="replace")),
+            "python",
+            line_numbers=True,
+            word_wrap=False,
+        )
+        self.source = source
+        self._rendered: dict[_RenderKey, list[Segment]] = {}
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        key: _RenderKey = (
+            options.max_width,
+            options.no_wrap,
+            options.ascii_only,
+            options.legacy_windows,
+            console.color_system,
+        )
+        segments = self._rendered.pop(key, None)
+        if segments is None:
+            # Console.render renders nested renderables with the height reset.
+            nested = options.reset_height()
+            segments = [
+                segment
+                for output in super().__rich_console__(console, options)
+                for segment in ((output,) if isinstance(output, Segment) else console.render(output, nested))
+            ]
+            if len(self._rendered) >= _RENDERED_WIDTHS:
+                del self._rendered[next(iter(self._rendered))]
+        self._rendered[key] = segments
+        yield from segments

chrys/app/tui/widgets/workflow/text.py

@@ -0,0 +1,257 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Localized workflow chrome; source, diagnostics and manifest names remain literal."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from chrys.app.tui.i18n import render_str
+from chrys.app.tui.util.formatting import elapsed_parts
+from chrys.foundation.i18n import MessageDef, MessageRef, msg
+from chrys.foundation.i18n.formatting import format_message, sanitize_legacy_block, sanitize_legacy_scalar
+from chrys.foundation.platform.files import surrogate_safe_text
+
+if TYPE_CHECKING:
+    from chrys.app.tui.i18n import LocaleController
+
+NEXT_NODE = msg("tui.workflow.binding.next_node", fallback="Next node")
+PREVIOUS_NODE = msg("tui.workflow.binding.previous_node", fallback="Previous node")
+OPEN_NODE = msg("tui.workflow.binding.open_node", fallback="Open node")
+NEXT_WORKFLOW = msg("tui.workflow.binding.next_workflow", fallback="Next workflow")
+PREVIOUS_WORKFLOW = msg("tui.workflow.binding.previous_workflow", fallback="Previous workflow")
+WORKSPACE_LOCKED_TITLE = msg("tui.workflow.workspace_locked_title", fallback="Workspace fixed")
+WORKSPACE_LOCKED = msg(
+    "tui.workflow.workspace_locked",
+    fallback="This workflow session is bound to its workspace. Once a run has started, the workspace cannot be changed. Use /new to create a session in another directory.",
+)
+WORKSPACE_SOURCE_LOCKED = msg(
+    "tui.workflow.workspace_source_locked",
+    fallback="This workflow is located in the current working directory. Create a new session to select a workflow in another directory.",
+)
+NEW_SESSION = msg("tui.workflow.new_session", fallback="New Session")
+
+MODE_CHAT = msg("tui.workflow.mode.chat", fallback="Chat")
+MODE_WORKFLOW = msg("tui.workflow.mode.workflow", fallback="Workflow")
+APP_MODE = msg("tui.workflow.mode.title", fallback="App Mode")
+MODE_BADGE = msg("tui.workflow.mode.badge", fallback=" APP MODE: {mode} ")
+MODE_BUSY_TITLE = msg("tui.workflow.mode.busy_title", fallback="Busy")
+MODE_AGENT_BUSY = msg("tui.workflow.mode.agent_busy", fallback="Cannot switch app mode while the agent is busy")
+MODE_WORKFLOW_BUSY = msg(
+    "tui.workflow.mode.workflow_busy",
+    fallback="Cannot switch app mode while a workflow is running",
+)
+CHAT_DESCRIPTION = msg("tui.workflow.mode.chat_description", fallback="Chat with an agent")
+WORKFLOW_DESCRIPTION = msg("tui.workflow.mode.workflow_description", fallback="Select and run a workflow")
+SESSION_TITLE = msg("tui.workflow.session_title", fallback="{name} · Session: {session_id}")
+TITLE = msg("tui.workflow.title", fallback="Workflow")
+BUILTIN = msg("tui.workflow.source.builtin", fallback="builtin")
+GLOBAL = msg("tui.workflow.source.global", fallback="global")
+PROJECT = msg("tui.workflow.source.project", fallback="project")
+SESSION_LOCKED = msg(
+    "tui.workflow.session_locked",
+    fallback="This session already has runs. Create a new session to select another workflow.",
+)
+SHADOWED = msg("tui.workflow.shadowed", fallback="shadowed")
+PREVIEW_TIMEOUT = msg("tui.workflow.preview_timeout", fallback="Workflow preview timed out.")
+CONFIRM_TITLE = msg("tui.workflow.confirm.title", fallback="Trust workflow")
+CONFIRM = msg("tui.workflow.confirm.button", fallback="Trust")
+CANCEL = msg("tui.workflow.cancel", fallback="Cancel")
+CANCEL_RUN_TITLE = msg("tui.workflow.cancel_run.title", fallback="Cancel workflow?")
+CANCEL_RUN_MESSAGE = msg(
+    "tui.workflow.cancel_run.message",
+    fallback="Cancel workflow run {run_id}? This stops the entire workflow. This run cannot be resumed; you can only start a new run.",
+)
+CANCEL_RUN_CONFIRM = msg("tui.workflow.cancel_run.confirm", fallback="Cancel workflow")
+KEEP_RUNNING = msg("tui.workflow.cancel_run.keep_running", fallback="Keep running")
+START = msg("tui.workflow.start", fallback="▶ Start")
+STARTING = msg("tui.workflow.starting", fallback="Starting…")
+STOP = msg("tui.workflow.stop", fallback="■ Cancel")
+RESULT = msg("tui.workflow.result", fallback="Result")
+RESULT_TITLE = msg("tui.workflow.result_title", fallback="Result · {node}")
+OUTPUTS = msg("tui.workflow.outputs", fallback="Outputs")
+OUTPUT_SUMMARY_ONLY = msg(
+    "tui.workflow.output.summary_only", fallback="Full output is unavailable. Only the saved summary is shown."
+)
+IDLE = msg("tui.workflow.state.idle", fallback="idle")
+PENDING = msg("tui.workflow.state.pending", fallback="pending")
+RUNNING = msg("tui.workflow.state.running", fallback="running")
+RETRYING = msg("tui.workflow.state.retrying", fallback="retrying")
+AWAITING_RETRY = msg("tui.workflow.state.awaiting_retry", fallback="awaiting retry")
+COMPLETED = msg("tui.workflow.state.completed", fallback="completed")
+FAILED = msg("tui.workflow.state.failed", fallback="failed")
+SKIPPED = msg("tui.workflow.state.skipped", fallback="skipped")
+CANCELLED = msg("tui.workflow.state.cancelled", fallback="cancelled")
+PICK_HINT = msg("tui.workflow.pick_hint", fallback="Pick a workflow before starting.")
+TURN_BUSY = msg(
+    "tui.workflow.turn_busy", fallback="Wait for the current execution to finish before starting a workflow."
+)
+COMMAND = msg("tui.workflow.command", fallback="Open Workflow mode and select a workflow")
+DEFAULT_MODEL = msg("tui.workflow.default_model", fallback="default model")
+NODE_FAILED = msg("tui.workflow.state.node_failed", fallback="node failed")
+LOOP_EXHAUSTED = msg("tui.workflow.state.loop_exhausted", fallback="loop exhausted")
+WORKER_LOST = msg("tui.workflow.state.worker_lost", fallback="worker lost")
+STORAGE_FAILED = msg("tui.workflow.state.storage_failed", fallback="storage failed")
+ORPHANED = msg("tui.workflow.state.orphaned", fallback="orphaned")
+NO_OUTPUTS = msg("tui.workflow.no_outputs", fallback="No outputs.")
+GRAPH_VIEW = msg("tui.workflow.tab.graph", fallback="Workflow")
+CODE_VIEW = msg("tui.workflow.tab.code", fallback="Source")
+STALE = msg("tui.workflow.stale", fallback="This workflow changed. Reopen it to preview and confirm before starting.")
+CODE_CHANGED = msg("tui.workflow.code_changed", fallback="This file differs from what was previewed.")
+DELETE = msg("tui.workflow.delete", fallback="Delete workflow")
+DELETE_PROJECT = msg(
+    "tui.workflow.delete_project", fallback="Project files may be recoverable in Git. Run history stays."
+)
+DELETE_GLOBAL = msg("tui.workflow.delete_global", fallback="Global files cannot be recovered. Run history stays.")
+DELETE_PACKAGE_NOTE = msg(
+    "tui.workflow.delete_package_note", fallback="Only {entry} is deleted. The other files in {folder} are kept."
+)
+DELETE_ACTIVE = msg("tui.workflow.delete_active", fallback="Stop this workflow before deleting its source.")
+INPUT = msg("tui.workflow.node.input", fallback="Input")
+COPY_RUN_INPUT = msg("tui.workflow.copy_run_input_tooltip", fallback="Copy raw run input")
+RUN_INPUT_COPIED = msg("tui.workflow.run_input_copied", fallback="Copied run input")
+OUTPUT = msg("tui.workflow.node.output", fallback="Output")
+TRANSCRIPT = msg("tui.workflow.node.transcript", fallback="Transcript")
+PREVIOUS_RUN = msg("tui.workflow.node.previous_run", fallback="Previous run")
+NO_RECORD = msg("tui.workflow.node.no_record", fallback="No record available.")
+NO_TRANSCRIPT = msg("tui.workflow.node.no_transcript", fallback="Transcript not available.")
+DATA_DROPPED = msg(
+    "tui.workflow.node.data_dropped",
+    fallback="Upstream structured data was dropped; this agent received only the text.",
+)
+ITERATION = msg("tui.workflow.node.iteration", fallback="Iteration {iteration}")
+ATTEMPT = msg("tui.workflow.node.attempt", fallback="Attempt {attempt}")
+RETRY = msg("tui.workflow.node.retry", fallback="Retry")
+STDOUT_TRUNCATED = msg("tui.workflow.node.stdout_truncated", fallback="Captured stdout was truncated.")
+VALUE_MARKDOWN = msg("tui.workflow.node.value.markdown", fallback="Markdown")
+VALUE_PLAIN = msg("tui.workflow.node.value.plain", fallback="Plain text")
+VALUE_DATA = msg("tui.workflow.node.value.data", fallback="Data")
+VALUE_PROGRESS = msg("tui.workflow.node.value.progress", fallback="Progress messages")
+STATUS_MESSAGES = msg("tui.workflow.status_messages", fallback="Recent status messages")
+ELAPSED_SECONDS = msg("tui.workflow.elapsed.seconds", fallback="{count} second", plural_fallback="{count} seconds")
+ELAPSED_MINUTES = msg("tui.workflow.elapsed.minutes", fallback="{count} minute", plural_fallback="{count} minutes")
+ELAPSED_HOURS = msg("tui.workflow.elapsed.hours", fallback="{count} hour", plural_fallback="{count} hours")
+ELAPSED_DAYS = msg("tui.workflow.elapsed.days", fallback="{count} day", plural_fallback="{count} days")
+LAYOUT_VERTICAL = msg("tui.workflow.layout.vertical", fallback="↕ Vertical")
+LAYOUT_HORIZONTAL = msg("tui.workflow.layout.horizontal", fallback="↔ Horizontal")
+LOOP_ITERATION = msg("tui.workflow.loop_iteration", fallback="Iteration {iteration}/{maximum}")
+
+PHASE_BODY = msg("tui.workflow.node.phase.body", fallback="Body")
+PHASE_OUTGOING = msg("tui.workflow.node.phase.outgoing", fallback="Outgoing conditions")
+PHASE_UNTIL = msg("tui.workflow.node.phase.until", fallback="Loop condition")
+PHASE_COMBINE = msg("tui.workflow.node.phase.combine", fallback="Combine")
+FAILED_PHASE = msg("tui.workflow.node.failed_phase", fallback="Failed during: {phase}")
+
+PHASES = {"body": PHASE_BODY, "outgoing": PHASE_OUTGOING, "until": PHASE_UNTIL, "combine": PHASE_COMBINE}
+
+SOURCES = {"builtin": BUILTIN, "global": GLOBAL, "project": PROJECT}
+
+
+@dataclass(frozen=True, slots=True)
+class StatePresentation:
+    label: MessageDef
+    node_component: str = "workflow-node--pending"
+    marker: str = "○"
+    edge_priority: int = 0
+    edge_component: str = "workflow-edge--pending"
+
+
+STATES = {
+    "node_failed": StatePresentation(NODE_FAILED),
+    "loop_exhausted": StatePresentation(LOOP_EXHAUSTED),
+    "worker_lost": StatePresentation(WORKER_LOST),
+    "storage_failed": StatePresentation(STORAGE_FAILED),
+    "orphaned": StatePresentation(ORPHANED),
+    "idle": StatePresentation(IDLE),
+    "pending": StatePresentation(PENDING),
+    "running": StatePresentation(RUNNING, "workflow-node--running", "●", 4, "workflow-edge--running"),
+    "retrying": StatePresentation(RETRYING, "workflow-node--warning", "↻", 2, "workflow-edge--retrying"),
+    "awaiting_retry": StatePresentation(
+        AWAITING_RETRY, "workflow-node--error", "!", 3, "workflow-edge--awaiting_retry"
+    ),
+    "completed": StatePresentation(COMPLETED, "workflow-node--success", "✓", 1, "workflow-edge--completed"),
+    "failed": StatePresentation(FAILED, "workflow-node--error", "✕", 3, "workflow-edge--failed"),
+    "skipped": StatePresentation(SKIPPED, "workflow-node--skipped", "╌", 0, "workflow-edge--skipped"),
+    "cancelled": StatePresentation(CANCELLED, "workflow-node--warning", "■", 2, "workflow-edge--cancelled"),
+}
+
+
+def state_presentation(state: str) -> StatePresentation:
+    return STATES.get(state, STATES["pending"])
+
+
+START_WORKFLOW = msg("tui.workflow.start_workflow", fallback="Start Workflow")
+RUN_SETTINGS = msg("tui.workflow.run_settings", fallback="Run Settings")
+INPUT_OPTIONAL = msg("tui.workflow.input_optional", fallback="Input · Optional")
+INPUT_HINT = msg(
+    "tui.workflow.input_hint",
+    fallback="Initial text passed to this workflow.",
+)
+DIRECTORY_SESSION_BOUND = msg(
+    "tui.workflow.directory_session_bound", fallback="This session is bound to its working directory."
+)
+DIRECTORY_SOURCE_BOUND = msg(
+    "tui.workflow.directory_source_bound", fallback="This workflow is located in the working directory."
+)
+MODEL_LABEL = msg("tui.workflow.model", fallback="Default Model")
+SELECT_MODEL = msg("tui.workflow.select_model", fallback="Select Model")
+WORKING_DIRECTORY = msg("tui.workflow.working_directory", fallback="Working Directory")
+CHANGE_DIRECTORY = msg("tui.workflow.change_directory", fallback="Browse")
+INVALID_DIRECTORY = msg("tui.workflow.invalid_directory", fallback="Not a valid directory: {path}")
+
+
+def shown(value: str, *, block: bool = False) -> str:
+    """A file name, path or workflow-supplied text made safe to display: no controls, no lone surrogates."""
+    safe = surrogate_safe_text(value)
+    return sanitize_legacy_block(safe) if block else sanitize_legacy_scalar(safe)
+
+
+def render(message: MessageRef, controller: LocaleController | None = None) -> str:
+    return format_message(message) if controller is None else render_str(controller.localizer, message)
+
+
+def state_label(state: str, controller: LocaleController | None = None) -> str:
+    presentation = STATES.get(state)
+    return render(presentation.label.bind(), controller) if presentation is not None else state
+
+
+def phase_label(phase: str, controller: LocaleController | None = None) -> str:
+    return render(PHASES[phase].bind(), controller) if phase in PHASES else phase
+
+
+def iteration_label(iteration: int, maximum: int, controller: LocaleController | None = None) -> str:
+    return render(LOOP_ITERATION.bind(iteration=iteration, maximum=maximum), controller)
+
+
+def elapsed_label(seconds: float, controller: LocaleController | None = None) -> str:
+    """Render at most two spelled-out duration units with localized plurals."""
+    units = {"d": ELAPSED_DAYS, "h": ELAPSED_HOURS, "m": ELAPSED_MINUTES, "s": ELAPSED_SECONDS}
+    return " ".join(render(units[unit].bind(count=value), controller) for value, unit in elapsed_parts(seconds))
+
+
+RUN_TAB = msg("tui.workflow.run_tab", fallback="Run {number}")
+LOAD_SESSION = msg("tui.workflow.load_session", fallback="Loading Workflow Session · {name}")
+LOAD_WORKFLOW = msg("tui.workflow.load_workflow", fallback="Loading Workflow · {name}")
+LOAD_DEFINITION = msg("tui.workflow.load.definition", fallback="Workflow definition")
+LOAD_ENVIRONMENT = msg("tui.workflow.load.environment", fallback="Execution environment")
+LOAD_GRAPH = msg("tui.workflow.load.graph", fallback="Workflow graph")
+LOAD_SESSION_RECORD = msg("tui.workflow.load.session_record", fallback="Reading session record")
+LOAD_SNAPSHOT = msg("tui.workflow.load.snapshot", fallback="Reading workflow snapshot")
+LOAD_STATUS = msg("tui.workflow.load.status", fallback="Restoring run and node states")
+SESSION_READ = msg("tui.workflow.session_read", fallback="Session record read")
+SNAPSHOT_READ = msg("tui.workflow.snapshot_read", fallback="Workflow snapshot read")
+STATUS_RESTORED = msg("tui.workflow.status_restored", fallback="Run status restored")
+NODES_LOADED = msg("tui.workflow.nodes_loaded", fallback="Node states loaded: {loaded}/{total}")
+
+OK = msg("tui.workflow.button.ok", fallback="OK")
+
+LOAD_OUTPUT = msg("tui.workflow.output.load", fallback="Load output")
+NATIVE_OUTPUT = msg("tui.workflow.output.native", fallback="Output outside nodes")
+OUTPUT_TRUNCATED = msg("tui.workflow.output.truncated", fallback="Some output was omitted by the capture limit.")
+ACP_STDERR = msg("tui.workflow.node.acp_stderr", fallback="ACP stderr: {path}")
+
+RESTORE_FALLBACK = msg(
+    "tui.workflow.restore.fallback",
+    fallback="The latest run is unavailable. Showing the newest readable run: {run_id}.",
+)

chrys/app/tui/widgets/workflow/values.py

@@ -0,0 +1,317 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Readable node values: tabs show ``text`` as Markdown or literal lines, and ``data`` as fields."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from collections.abc import Mapping
+from dataclasses import dataclass
+from enum import StrEnum
+from typing import TYPE_CHECKING, Any
+
+from rich.table import Table
+from rich.text import Text
+from textual import on
+from textual.containers import Vertical, VerticalGroup, VerticalScroll
+from textual.widgets import Static, Tab, Tabs
+
+from chrys.app.tui.util.removal import remove_children_shielded
+from chrys.app.tui.util.source_text import sanitize_source_text
+from chrys.app.tui.widgets.chat.tool_view_builders import (
+    TOOL_VIEW_EMPTY,
+    ToolViewContent,
+    build_code_view,
+    build_params_view,
+)
+from chrys.app.tui.widgets.markdown import VirtualizedMarkdown
+from chrys.app.tui.widgets.markdown.parser import create_line_break_markdown_parser
+from chrys.app.tui.widgets.workflow import text
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+    from textual.widget import Widget
+
+    from chrys.app.tui.i18n import LocaleController
+    from chrys.foundation.i18n import MessageRef
+
+HIGHLIGHT_MAX_CHARS = 200_000
+"""Larger data renders as literal JSON: highlighting and table layout run on the UI thread."""
+
+_TAB_ID_PREFIX = "workflow-value-"
+
+
+class ValueTab(StrEnum):
+    MARKDOWN = "markdown"
+    PLAIN = "plain"
+    DATA = "data"
+    PROGRESS = "progress"
+
+
+_TAB_LABELS = {
+    ValueTab.MARKDOWN: text.VALUE_MARKDOWN,
+    ValueTab.PLAIN: text.VALUE_PLAIN,
+    ValueTab.DATA: text.VALUE_DATA,
+    ValueTab.PROGRESS: text.VALUE_PROGRESS,
+}
+
+
+@dataclass(frozen=True, slots=True)
+class ShownValue:
+    """One ``WorkflowValue``; ``source`` names the join input it arrived from."""
+
+    text: str = ""
+    data: Any = None
+    source: str = ""
+
+
+@dataclass(frozen=True, slots=True)
+class ValueDocument:
+    """Everything one record pane shows; ``placeholder`` stands in when there is nothing else."""
+
+    values: tuple[ShownValue, ...] = ()
+    emits: tuple[tuple[int, str], ...] = ()
+    notice: str = ""
+    placeholder: str = ""
+
+
+def shown_value(value: Any, *, source: str = "") -> ShownValue:
+    """Read a stored ``{text, data}`` envelope; any other shape is kept whole as data."""
+    if isinstance(value, str):
+        return ShownValue(value, source=source)
+    if isinstance(value, dict) and isinstance(value.get("text"), str) and value.keys() <= {"text", "data"}:
+        return ShownValue(value["text"], value.get("data"), source)
+    return ShownValue(data=value, source=source)
+
+
+def record_values(record: Mapping[str, Any]) -> tuple[ShownValue, ...]:
+    """A node record's ``value``, or each of a join's ``sources`` titled by its node."""
+    sources = record.get("sources")
+    if not isinstance(sources, list):
+        return (shown_value(record.get("value")),)
+    return tuple(
+        shown_value(source.get("value"), source=str(source.get("node_id", "")))
+        if isinstance(source, dict)
+        else shown_value(source)
+        for source in sources
+    )
+
+
+def value_tabs(document: ValueDocument) -> tuple[ValueTab, ...]:
+    """The tabs with something to show: text only when a value has some, or has no data either."""
+    tabs: list[ValueTab] = []
+    if any(value.text or value.data is None for value in document.values):
+        tabs += (ValueTab.MARKDOWN, ValueTab.PLAIN)
+    if any(value.data is not None for value in document.values):
+        tabs.append(ValueTab.DATA)
+    if document.emits:
+        tabs.append(ValueTab.PROGRESS)
+    return tuple(tabs)
+
+
+def _header_key(document: ValueDocument) -> tuple[str, tuple[ValueTab, ...]]:
+    return document.notice, value_tabs(document)
+
+
+class WorkflowValueView(Vertical):
+    """Value tabs over the shown tab's content; each view keeps the reader's tab while its records change.
+
+    With ``scroll`` the tab bar stays put above a scrolling area holding the content, followed by
+    ``trailing`` widgets that the view never rebuilds. Without ``view_tabs`` there is no tab bar: the view
+    shows its first tab (Markdown, or Data for a value that has only data).
+    """
+
+    DEFAULT_CSS = """
+    WorkflowValueView { width: 100%; height: auto; }
+    WorkflowValueView.-scroll { height: 1fr; }
+    WorkflowValueView .workflow-value-header,
+    WorkflowValueView .workflow-value-body { width: 100%; height: auto; }
+    WorkflowValueView .workflow-value-scroll { height: 1fr; scrollbar-size-vertical: 1; }
+    WorkflowValueView .workflow-value-notice {
+        width: 100%; height: auto; margin: 0 0 1 0; padding: 0 1;
+        border-left: outer $tui-border-warning; background: $warning 10%; color: $text-warning;
+    }
+    WorkflowValueView .workflow-value-tabs { margin: 0 0 1 0; }
+    WorkflowValueView .workflow-value-body .tool-view-md,
+    WorkflowValueView .workflow-value-body .tool-view-text,
+    WorkflowValueView .workflow-value-body .tool-view-code,
+    WorkflowValueView .workflow-value-body .tool-view-params,
+    WorkflowValueView .workflow-value-body .tool-view-section-title { padding: 0 1; }
+    WorkflowValueView .workflow-value-empty { color: $text-muted; text-style: italic; }
+    WorkflowValueView .workflow-value-source {
+        width: 100%; height: auto; margin: 0 0 1 0;
+        border: round $tui-border-primary 40%; border-title-color: $text-primary; border-title-style: bold;
+    }
+    WorkflowValueView .workflow-value-body > *:last-child,
+    WorkflowValueView .workflow-value-body ToolViewContent > *:last-child { margin-bottom: 0; }
+    WorkflowValueView .workflow-value-emits { width: 100%; height: auto; padding: 0 1; }
+    WorkflowValueView .workflow-value-placeholder { width: 100%; height: auto; color: $text-muted; }
+    """
+
+    def __init__(
+        self,
+        locale: LocaleController | None,
+        *trailing: Widget,
+        scroll: bool = False,
+        view_tabs: bool = True,
+        id: str | None = None,
+    ) -> None:
+        super().__init__(id=id, classes="-scroll" if scroll else "")
+        self._locale = locale
+        self._trailing = trailing
+        self._view_tabs = view_tabs
+        self.header = VerticalGroup(classes="workflow-value-header")
+        """The notice and the tab bar."""
+        self.body = VerticalGroup(classes="workflow-value-body")
+        """The shown tab's content, or the placeholder."""
+        self.scroll = VerticalScroll(classes="workflow-value-scroll") if scroll else None
+        self.document = ValueDocument()
+        self.selected = ValueTab.MARKDOWN
+        """The reader's tab; a document without it shows its first tab instead."""
+        self._shown: tuple[ValueDocument, ValueTab | None] | None = None
+        self._header_shown: tuple[str, tuple[ValueTab, ...]] | None = None
+        self._tabs: Tabs | None = None
+        """The tab bar of the header; activations from a bar the header has replaced are ignored."""
+        self._lock = asyncio.Lock()
+
+    def compose(self) -> ComposeResult:
+        yield self.header
+        if self.scroll is None:
+            yield self.body
+            yield from self._trailing
+            return
+        with self.scroll:
+            yield self.body
+            yield from self._trailing
+
+    @property
+    def shown_tab(self) -> ValueTab | None:
+        tabs = value_tabs(self.document)
+        return self.selected if self.selected in tabs else next(iter(tabs), None)
+
+    async def show(self, document: ValueDocument) -> None:
+        """Display the latest document; a caller that waited for an older rebuild renders the newest one."""
+        self.document = document
+        await self._rebuild()
+
+    async def select(self, tab: ValueTab) -> None:
+        self.selected = tab
+        await self._rebuild()
+
+    @on(Tabs.TabActivated, ".workflow-value-tabs")
+    def tab_activated(self, event: Tabs.TabActivated) -> None:
+        """The reader's choice: rebuilds change the tab bar without posting activations."""
+        event.stop()
+        tab = ValueTab((event.tab.id or "").removeprefix(_TAB_ID_PREFIX))
+        if event.tabs is not self._tabs or tab is self.shown_tab:
+            return
+        # Recorded now, so that the next activation compares against it before the rebuild runs.
+        self.selected = tab
+        # Rebuilding awaits mounts that this view's own message pump completes.
+        self.run_worker(self._rebuild(), group="workflow-value-tab", exclusive=True)
+
+    async def _rebuild(self) -> None:
+        async with self._lock:
+            document, tab = self.document, self.shown_tab
+            shown = self._shown
+            if (document, tab) == shown or not self.is_attached:
+                return
+            # A cancelled rebuild must not leave a stale match behind.
+            self._shown = None
+            with self.app.batch_update():
+                header = _header_key(document)
+                if header != self._header_shown:
+                    self._header_shown = self._tabs = None
+                    await remove_children_shielded(self.header)
+                    # Removal runs through the message loop, which may have detached this view meanwhile.
+                    if not self.header.is_attached:
+                        return
+                    await self.header.mount_all(self._header_widgets(document, tab))
+                    self._header_shown = header
+                elif self._tabs is not None and tab is not None:
+                    # The same tabs: keep the tab bar, and the keyboard focus on it.
+                    with self.prevent(Tabs.TabActivated):
+                        self._tabs.active = _TAB_ID_PREFIX + tab
+                await remove_children_shielded(self.body)
+                if not self.body.is_attached:
+                    return
+                await self.body.mount_all(self._body_widgets(document, tab))
+                if self.scroll is not None and shown is not None and shown[0] == document:
+                    # Another tab of the same record opens at its top.
+                    self.scroll.scroll_home(animate=False, immediate=True)
+            self._shown = (document, tab)
+
+    def _text(self, message: MessageRef) -> str:
+        return text.render(message, self._locale)
+
+    def _dark(self) -> bool:
+        return self.app.current_theme.dark
+
+    def _header_widgets(self, document: ValueDocument, tab: ValueTab | None) -> list[Widget]:
+        widgets: list[Widget] = []
+        if document.notice:
+            widgets.append(Static(Text(document.notice), classes="workflow-value-notice"))
+        if tab is not None and self._view_tabs:
+            tabs = [
+                Tab(Text(self._text(_TAB_LABELS[option].bind())), id=_TAB_ID_PREFIX + option)
+                for option in value_tabs(document)
+            ]
+            # A bar posts an activation for its first tab when it mounts; that is not the reader's choice.
+            with self.prevent(Tabs.TabActivated):
+                self._tabs = Tabs(*tabs, active=_TAB_ID_PREFIX + tab, classes="workflow-value-tabs")
+            widgets.append(self._tabs)
+        return widgets
+
+    def _body_widgets(self, document: ValueDocument, tab: ValueTab | None) -> list[Widget]:
+        if tab is None:
+            return [Static(Text(document.placeholder), classes="workflow-value-placeholder")]
+        return self._tab_widgets(document, tab)
+
+    def _tab_widgets(self, document: ValueDocument, tab: ValueTab) -> list[Widget]:
+        if tab is ValueTab.PROGRESS:
+            table = Table.grid(padding=(0, 1))
+            table.add_column(style="dim", justify="right", no_wrap=True)
+            table.add_column(overflow="fold")
+            for ordinal, line in document.emits:
+                table.add_row(str(ordinal), Text(sanitize_source_text(line, tab_size=8)))
+            return [Static(table, classes="workflow-value-emits")]
+        widgets: list[Widget] = []
+        for value in document.values:
+            content = ToolViewContent(self._value_widgets(value, tab))
+            if value.source:
+                box = Vertical(content, classes="workflow-value-source")
+                box.border_title = Text(value.source)
+                widgets.append(box)
+            else:
+                widgets.append(content)
+        return widgets
+
+    def _value_widgets(self, value: ShownValue, tab: ValueTab) -> list[Widget]:
+        if tab is ValueTab.DATA:
+            return self._empty() if value.data is None else self._data_widgets(value.data)
+        if not value.text:
+            return self._empty()
+        if tab is ValueTab.MARKDOWN:
+            # Values are often line-oriented program output, so newlines stay line breaks.
+            return [
+                VirtualizedMarkdown(
+                    sanitize_source_text(value.text),
+                    classes="tool-view-md",
+                    parser_factory=create_line_break_markdown_parser,
+                )
+            ]
+        return [build_code_view("text", value.text.rstrip("\r\n"), render_message=self._text)]
+
+    def _data_widgets(self, data: Any) -> list[Widget]:
+        pretty = json.dumps(data, indent=2, ensure_ascii=False)
+        if len(pretty) > HIGHLIGHT_MAX_CHARS:
+            return [build_code_view("text", pretty, render_message=self._text)]
+        if isinstance(data, dict) and data:
+            return build_params_view(data, dark=self._dark(), render_message=self._text)
+        if isinstance(data, str):
+            return [build_code_view("text", data, render_message=self._text)]
+        return [build_code_view("json", pretty, dark=self._dark(), render_message=self._text)]
+
+    def _empty(self) -> list[Widget]:
+        return [Static(Text(self._text(TOOL_VIEW_EMPTY.bind())), classes="tool-view-text workflow-value-empty")]

chrys/foundation/branding.py

@@ -0,0 +1,15 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""User-facing product branding."""
+
+from __future__ import annotations
+
+APP_DISPLAY_NAME = "iCode"
+# The command users are shown. ``chrys`` stays installed beside it, and everything
+# internal (package, config directory, CHRYS_* variables) keeps the original name.
+APP_COMMAND = "icode"
+
+
+def format_app_version_title(version: str) -> str:
+    """Return the user-facing application title with a version suffix."""
+    return f"{APP_DISPLAY_NAME} v{version}"

chrys/foundation/config/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Configuration — settings and platform detection."""
+
+from chrys.foundation.config.settings import Settings
+
+__all__ = ["Settings"]