iCode-TUI 0.29.1__py3-none-any.whl

chrys/app/tui/widgets/loading.py

@@ -0,0 +1,125 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Shared loading indicator widgets."""
+
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING, Protocol, cast
+
+from rich.style import Style
+from rich.text import Text
+from textual.color import Color, Gradient
+from textual.geometry import Region
+from textual.strip import Strip
+from textual.widgets import LoadingIndicator
+
+from chrys.app.tui.i18n import render_text
+from chrys.app.tui.util.visibility import is_widget_shown_on_active_screen
+from chrys.foundation.i18n import msg
+from chrys.foundation.i18n.formatting import format_message
+
+if TYPE_CHECKING:
+    from chrys.app.tui.i18n import LocaleController
+
+_LOADING = msg("tui.loading.label", fallback="Loading...")
+
+
+class _LocaleControllerApp(Protocol):
+    @property
+    def locale_controller(self) -> LocaleController: ...
+
+
+class ChrysLoadingIndicator(LoadingIndicator):
+    """LoadingIndicator with a brighter gradient floor for transparent themes.
+
+    Its 16/s refresh timer ticks only while the indicator is composited, between
+    Textual's Show and Hide events, and its owner wants it animated
+    (``resume_animation``). The compositor maps neither ``display: none`` nor
+    ``visibility: hidden`` widgets, and Chrys's layout-free visibility flips post
+    the same Show/Hide as a reflow, so a spinner inside a hidden container, a
+    collapsed tool group or an idle status bar costs no timer ticks at all; on
+    Windows every tick used to be an executor-thread hop.
+    """
+
+    _composited = False
+    """Whether the compositor maps this widget: set by Show, cleared by Hide."""
+    _animating = True
+    """The owner's intent: ``pause_animation`` parks the timer even while composited."""
+
+    def pause_animation(self) -> None:
+        """Park the refresh timer while the owner shows the indicator idle."""
+        self._animating = False
+        self._sync_timer()
+
+    def resume_animation(self) -> None:
+        """Let the refresh timer run again once the owner shows activity."""
+        self._animating = True
+        self._sync_timer()
+
+    def on_show(self) -> None:
+        self._composited = True
+        self._sync_timer()
+
+    def on_hide(self) -> None:
+        self._composited = False
+        self._sync_timer()
+
+    def _sync_timer(self) -> None:
+        timer = self._auto_refresh_timer
+        if timer is None:
+            return
+        if self._animating and self._composited:
+            timer.resume()
+        else:
+            timer.pause()
+
+    def automatic_refresh(self) -> None:
+        """Animate only on the active screen, without arranging the tree.
+
+        ``DOMNode.automatic_refresh`` gates on ``is_on_screen``, which goes
+        through ``Screen.find_widget`` and recomputes the compositor's full
+        map whenever it was invalidated. With ``auto_refresh`` at 16/s that
+        turns every invalidation (scroll ticks, any layout change) into an
+        O(all mounted widgets) arrange pass — even while this indicator is
+        hidden inside a collapsed status section.
+        """
+        if is_widget_shown_on_active_screen(self):
+            self.refresh()
+        if not (self._animating and self._composited):
+            # No Show is coming for a spinner mounted inside a hidden container,
+            # and a timer may start after the owner's pause: the first tick parks it.
+            # Painting is gated above on the compositor's cut, not on Show having
+            # been processed, so a freshly shown spinner still paints this tick.
+            self._sync_timer()
+
+    def render_lines(self, crop: Region) -> list[Strip]:
+        if not self.is_attached:
+            return [Strip.blank(crop.width) for _ in crop.line_range]
+        return super().render_lines(crop)
+
+    def render(self) -> Text:
+        if not self.is_attached:
+            return Text(format_message(_LOADING.bind()))
+        if self.app.animation_level == "none":
+            try:
+                localizer = cast("_LocaleControllerApp", self.app).locale_controller.localizer
+            except AttributeError, RuntimeError:
+                return Text(format_message(_LOADING.bind()))
+            return render_text(localizer, _LOADING.bind())
+        elapsed = time.time() - self._start_time
+        speed = 0.8
+        dot = "\u25cf"
+        _, _, _bg, color = self.colors
+        # Dim end: desaturate towards grey for a muted appearance.
+        dim = color.blend(Color(50, 50, 50), 0.75)
+        gradient = Gradient(
+            (0.0, dim),
+            (0.7, color),
+            (1.0, color.lighten(0.1)),
+        )
+        blends = [(elapsed * speed - i / 8) % 1 for i in range(5)]
+        dots = [(f"{dot} ", Style.from_color(gradient.get_color((1 - b) ** 2).rich_color)) for b in blends]
+        indicator = Text.assemble(*dots)
+        indicator.rstrip()
+        return indicator

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

@@ -0,0 +1,25 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Virtualized Markdown widget package for Textual.
+
+Provides a high-performance, virtualizing Markdown renderer with streaming support.
+Named VirtualizedMarkdown to avoid conflicts with Textual's built-in Markdown widget.
+"""
+
+from chrys.app.tui.widgets.markdown.blocks import MarkdownBlock, MarkdownFence, TableOfContentsType
+from chrys.app.tui.widgets.markdown.navigator import Navigator
+from chrys.app.tui.widgets.markdown.stream import MarkdownStream
+from chrys.app.tui.widgets.markdown.toc import MarkdownTableOfContents
+from chrys.app.tui.widgets.markdown.viewer import VirtualizedMarkdownViewer
+from chrys.app.tui.widgets.markdown.widget import VirtualizedMarkdown
+
+__all__ = [
+    "MarkdownBlock",
+    "MarkdownFence",
+    "MarkdownStream",
+    "MarkdownTableOfContents",
+    "Navigator",
+    "TableOfContentsType",
+    "VirtualizedMarkdown",
+    "VirtualizedMarkdownViewer",
+]

chrys/app/tui/widgets/markdown/_utils.py

@@ -0,0 +1,21 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Utility helpers for the virtualized markdown package."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def sanitize_location(location: str) -> tuple[Path, str]:
+    """Given a location, break out the path and any anchor.
+
+    Args:
+        location: The location to sanitize.
+
+    Returns:
+        A tuple of the path to the location cleaned of any anchor, plus
+        the anchor (or an empty string if none was found).
+    """
+    location, _, anchor = location.partition("#")
+    return Path(location), anchor

chrys/app/tui/widgets/markdown/anchors.py

@@ -0,0 +1,71 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Heading anchors — which ``#fragment`` a markdown heading answers to.
+
+Links are written for GitHub, whose heading ids keep every letter, CJK
+included, and drop punctuation: "智能体、模型与请求" is ``#智能体模型与请求``
+and "在本机启动 iCode" is ``#在本机启动-icode``. Textual's own slug removes
+CJK entirely, so under it those two headings would become ``""`` and
+``-icode``, and two different headings could share an id. A fragment is
+therefore matched against GitHub's id first, then Textual's slug, then the
+raw heading title.
+"""
+
+from __future__ import annotations
+
+import unicodedata
+from collections.abc import Sequence
+
+from textual._slug import TrackedSlugs
+
+# Besides letters and marks, GitHub keeps decimal digits, letter numbers
+# (Ⅻ) and connector punctuation (``_``), but drops other numbers (², ½).
+_KEPT_CATEGORIES = frozenset({"Nd", "Nl", "Pc"})
+
+
+def github_slug(title: str) -> str:
+    """Return GitHub's id for a heading, before duplicate numbering.
+
+    Lowercase, keep word characters, ``-`` and spaces, and turn each space
+    into a hyphen.
+    """
+    kept = "".join(char for char in title.lower() if char in "- " or _is_word_character(char))
+    return kept.replace(" ", "-")
+
+
+def _is_word_character(char: str) -> bool:
+    category = unicodedata.category(char)
+    return category[0] in "LM" or category in _KEPT_CATEGORIES
+
+
+class _GitHubSlugs:
+    """GitHub's duplicate numbering: the second "Usage" becomes ``usage-1``."""
+
+    def __init__(self) -> None:
+        self._occurrences: dict[str, int] = {}
+
+    def slug(self, title: str) -> str:
+        original = result = github_slug(title)
+        while result in self._occurrences:
+            self._occurrences[original] += 1
+            result = f"{original}-{self._occurrences[original]}"
+        self._occurrences[result] = 0
+        return result
+
+
+def find_heading(titles: Sequence[str], fragment: str) -> int | None:
+    """Return the index of the heading *fragment* names, or ``None``.
+
+    *titles* are the plain heading texts in document order, *fragment* the
+    decoded link target after ``#``.
+    """
+    if not fragment:
+        return None
+    github = _GitHubSlugs()
+    textual = TrackedSlugs()
+    keys = [(github.slug(title), textual.slug(title), title) for title in titles]
+    for tier in range(3):
+        for index, key in enumerate(keys):
+            if key[tier] == fragment:
+                return index
+    return None

chrys/app/tui/widgets/markdown/blocks.py

@@ -0,0 +1,115 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Data structures for parsed markdown blocks."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Literal
+
+from textual.content import Content
+
+if TYPE_CHECKING:
+    from chrys.app.tui.widgets.markdown.diagram.model import CompiledDiagram
+    from chrys.app.tui.widgets.markdown.math import CompiledMath
+
+type TableOfContentsType = list[tuple[int, str, str | None]]
+"""Information about the table of contents of a markdown document.
+
+The triples encode the level, the label, and the optional block id of each heading.
+"""
+
+BULLETS = ["\u2022 ", "\u25aa ", "\u2023 ", "\u2b51 ", "\u25e6 "]
+"""Unicode bullets used for unordered lists."""
+
+NUMERALS = " \u2160\u2161\u2162\u2163\u2164\u2165\u2166"
+
+
+@dataclass(frozen=True)
+class MarkdownGutter:
+    """One ordered container in a block's left gutter, shared by wrapped rows."""
+
+    container_id: int
+    kind: Literal["list", "quote"]
+    width: int
+    prefix: str = ""
+
+
+@dataclass
+class MarkdownBlock:
+    """Data object representing a parsed markdown block element."""
+
+    block_type: str
+    """The type of block (e.g. 'paragraph', 'heading', 'fence', 'hr', etc.)."""
+    content: Content
+    """The rendered Content for this block."""
+    level: int = 0
+    """The heading level (1-6) for heading blocks, or nesting level for lists."""
+    block_id: str | None = None
+    """An optional ID for the block (used for heading anchors)."""
+    source_range: tuple[int, int] = (0, 0)
+    """The (start_line, end_line) range in the source document."""
+    style_name: str = ""
+    """CSS component class name for styling."""
+    top_margin: int = 0
+    """Lines of margin above this block."""
+    bottom_margin: int = 1
+    """Lines of margin below this block."""
+    indent: int = 0
+    """Left indentation in cells."""
+    prefix: str = ""
+    """A prefix string (e.g. bullet character) to render before the first line."""
+    padding_top: int = 0
+    """Lines of padding above content (rendered with block style, unlike margin)."""
+    padding_bottom: int = 0
+    """Lines of padding below content (rendered with block style, unlike margin)."""
+    padding_left: int = 0
+    """Cells of padding to the left of content."""
+    padding_right: int = 0
+    """Cells of padding to the right of content (inside block background)."""
+    border_left: str = ""
+    """Character to render as a left border on every content line."""
+    bq_depth: int = 0
+    """Blockquote nesting depth (0 = not in blockquote)."""
+    gutter: tuple[MarkdownGutter, ...] = ()
+    """List and quote containers in source order; IDs distinguish adjacent quotes."""
+    text_align: str = "left"
+    """Text alignment: 'left', 'center', or 'right'."""
+    code_language: str = ""
+    """Language for code blocks."""
+    is_header_row: bool = False
+    """Whether this is a table header row."""
+    table_headers: list[Content] | None = None
+    """Header contents for table blocks."""
+    table_rows: list[list[Content]] | None = None
+    """Row contents for table blocks."""
+    diagram: CompiledDiagram | None = None
+    """Compiled terminal diagram payload for diagram blocks."""
+    math: CompiledMath | None = None
+    """Formula canvas; content retains its source for lossless narrow layouts."""
+
+
+class MarkdownFence:
+    """Compatibility shim - references MarkdownBlock internally.
+
+    This class exists to preserve the public API for code that checks
+    `isinstance(block, MarkdownFence)`.
+    """
+
+
+@dataclass
+class _BlockLineInfo:
+    """Cached rendering information for a markdown block."""
+
+    block_index: int
+    """Index into the blocks list."""
+    start_line: int
+    """First virtual line occupied by this block."""
+    height: int
+    """Total height in virtual lines (including margins)."""
+    content_height: int
+    """Height of the content itself (without margins)."""
+    top_margin: int
+    """Top margin lines."""
+    bottom_margin: int
+    """Bottom margin lines."""

chrys/app/tui/widgets/markdown/copyable.py

@@ -0,0 +1,163 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""CopyableMarkdown — VirtualizedMarkdown with copy buttons on code fences.
+
+Each fence block gets a clickable "copy" button rendered in its bottom
+padding. Clicking the button copies the raw code to the clipboard.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING, ClassVar
+
+from rich.segment import Segment, cell_len
+from rich.style import Style as RichStyle
+from textual.events import Click
+from textual.strip import Strip
+
+from chrys.app.tui.clipboard import copy_text_to_clipboards
+from chrys.app.tui.copy_messages import COPIED_TITLE
+from chrys.app.tui.i18n import render_str, widget_localizer
+from chrys.app.tui.widgets.markdown.blocks import MarkdownBlock, _BlockLineInfo
+from chrys.app.tui.widgets.markdown.widget import VirtualizedMarkdown
+from chrys.foundation.i18n import MessageRef, msg
+
+if TYPE_CHECKING:
+    pass
+
+_COPY_BUTTON_RIGHT_MARGIN = 4
+_CODE_BLOCK_COPIED = msg(
+    "tui.markdown.copy.code_block",
+    fallback="Code block copied to clipboard",
+)
+_CODE_BLOCK_COPIED_REF = _CODE_BLOCK_COPIED.bind()
+_COPIED_TITLE_REF = COPIED_TITLE.bind()
+
+
+class CopyableMarkdown(VirtualizedMarkdown):
+    """Markdown widget with copyable code blocks.
+
+    Each fence block has a copy button displayed below the code.
+    Clicking the button copies the code to the clipboard.
+    """
+
+    COMPONENT_CLASSES: ClassVar[set[str]] = VirtualizedMarkdown.COMPONENT_CLASSES | {
+        "markdown--copy-button",
+    }
+
+    DEFAULT_CSS = """
+    CopyableMarkdown {
+        background: transparent;
+
+        & > .markdown--copy-button {
+            background: transparent;
+            text-style: underline;
+            color: $text-muted;
+        }
+    }
+    """
+
+    def __init__(
+        self,
+        markdown: str | None = None,
+        *,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+        parser_factory: Callable | None = None,
+        open_links: bool = True,
+        copy_button_text: str = "📋 Copy",
+        copy_success_text: MessageRef | str = _CODE_BLOCK_COPIED_REF,
+        copy_success_title: MessageRef | str = _COPIED_TITLE_REF,
+    ):
+        super().__init__(
+            markdown,
+            name=name,
+            id=id,
+            classes=classes,
+            parser_factory=parser_factory,
+            open_links=open_links,
+        )
+        self._copy_button_text = copy_button_text
+        self._copy_success_text = copy_success_text
+        self._copy_success_title = copy_success_title
+        self._copy_button_lines: dict[int, int] = {}
+        """Mapping from virtual line number (copy button line) to block index."""
+
+    def _build_blocks(self, markdown: str) -> list[MarkdownBlock]:
+        blocks = super()._build_blocks(markdown)
+        for block in blocks:
+            if block.block_type == "fence":
+                # A footer belongs to the block, even when it ends the document.
+                block.padding_bottom += 1
+        return blocks
+
+    def _layout_blocks(self, width: int | None = None) -> None:
+        super()._layout_blocks(width)
+
+        # Build copy-button-line → block-index mapping.
+        self._copy_button_lines.clear()
+        for idx, block in enumerate(self._blocks):
+            if block.block_type == "fence":
+                info = self._block_line_info[idx]
+                copy_line = info.start_line + info.top_margin + info.content_height - 1
+                self._copy_button_lines[copy_line] = idx
+
+    def _render_block_line(self, block: MarkdownBlock, info: _BlockLineInfo, line: int, width: int) -> Strip:
+        if line in self._copy_button_lines:
+            return self._render_copy_button(block, width)
+        return super()._render_block_line(block, info, line, width)
+
+    def _copy_button_region(self, block: MarkdownBlock, width: int) -> tuple[int, int]:
+        """Use the same clipped button bounds for painting and hit testing."""
+        gutter_width = block.indent + len(block.border_left)
+        end = max(gutter_width, width - _COPY_BUTTON_RIGHT_MARGIN)
+        start = max(gutter_width, end - cell_len(self._copy_button_text))
+        return min(start, width), min(end, width)
+
+    def _render_copy_button(self, block: MarkdownBlock, width: int) -> Strip:
+        copy_text = self._copy_button_text
+        button_style = self._safe_component_style("markdown--copy-button").rich_style
+        style = self._get_bq_depth_style(block.bq_depth) if block.bq_depth else self.visual_style
+        start, end = self._copy_button_region(block, width)
+        gutter = Strip(self._render_block_gutter(block)).adjust_cell_length(start, style.rich_style)
+        button = Strip([Segment(copy_text, button_style + RichStyle(bgcolor=style.rich_style.bgcolor))]).crop(
+            0, end - start
+        )
+        strip = Strip([*gutter._segments, *button._segments]).adjust_cell_length(max(0, width - 1), style.rich_style)
+        return Strip([*strip._segments, Segment(" ", self.visual_style.rich_style)], width)
+
+    def on_click(self, event: Click) -> None:
+        offset = event.get_content_offset(self)
+        if offset is None:
+            return
+        virtual_y = offset.y + self.scroll_offset.y
+
+        if virtual_y not in self._copy_button_lines:
+            super().on_click(event)
+            return
+
+        block_index = self._copy_button_lines[virtual_y]
+        block = self._blocks[block_index]
+
+        # Hit-test: is the click within the button text?
+        width = self.scrollable_content_region.width
+
+        button_start, button_end = self._copy_button_region(block, width)
+
+        if button_start <= offset.x < button_end:
+            code = block.content.plain
+            copy_text_to_clipboards(self.app, code)
+            self.notify(
+                self._render_toast(self._copy_success_text),
+                title=self._render_toast(self._copy_success_title),
+                markup=False,
+            )
+            event.prevent_default()
+            event.stop()
+
+    def _render_toast(self, message: MessageRef | str) -> str:
+        if isinstance(message, str):
+            return message
+        return render_str(widget_localizer(self), message)

chrys/app/tui/widgets/markdown/diagram/__init__.py

@@ -0,0 +1,35 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Offline Mermaid-subset compiler for terminal Markdown rendering."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from chrys.foundation.i18n import MessageRef
+
+from .layout import compile_ir
+from .model import CompiledDiagram, Diagnostic, DiagnosticCode, DiagnosticSeverity, DiagramKind
+from .parser import parse_mermaid
+
+__all__ = [
+    "CompiledDiagram",
+    "Diagnostic",
+    "DiagnosticCode",
+    "DiagnosticSeverity",
+    "DiagramKind",
+    "compile_mermaid",
+]
+
+
+def compile_mermaid(
+    source: str,
+    *,
+    render_message: Callable[[MessageRef], str] | None = None,
+) -> CompiledDiagram:
+    """Compile bounded Mermaid source into immutable plain terminal rows.
+
+    Malformed, unsupported, and oversized user input produces a diagnostic
+    canvas. Expected input failures do not raise exceptions.
+    """
+    return compile_ir(source, parse_mermaid(source), render_message=render_message)