iCode-TUI 0.29.1__py3-none-any.whl

chrys/app/tui/widgets/diff_view/unified.py

@@ -0,0 +1,267 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""A unified diff drawn by one widget, for places where something else does the scrolling."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import ClassVar
+
+from textual.cache import LRUCache
+from textual.content import Content
+from textual.dom import NoScreen
+from textual.geometry import Offset, Region, Size
+from textual.selection import Selection
+from textual.strip import Strip
+from textual.style import Style as VisualStyle
+from textual.widget import Widget
+
+from chrys.app.tui.support.gc_freeze import detach_lru_cache, renew_lru_cache
+from chrys.app.tui.widgets import HATCH_GLYPH, normalize_selection_rich_style
+from chrys.app.tui.widgets.diff_view.cells import (
+    ANNOTATION_WIDTH,
+    COLLAPSED_ANNOTATION_WIDTH,
+    annotation_cell,
+    number_cell,
+    number_cell_width,
+)
+from chrys.app.tui.widgets.diff_view.palette import DiffLook
+from chrys.app.tui.widgets.diff_view.rows import DiffRow, Side
+
+
+class UnifiedDiffLines(Widget):
+    """Both line numbers, the annotation and the code of every row, as lines of a single widget.
+
+    `DiffView` lays a unified diff out as gutter columns around a code column, so that the code
+    can scroll under its own scrollbars. The chat shows diffs at their full height and scrolls
+    them with the transcript. Columns kept in step would be compositor work for nothing there,
+    so this widget draws the same cells and the same code side by side in one line.
+    """
+
+    ALLOW_SELECT = True
+
+    COMPONENT_CLASSES: ClassVar[set[str]] = {"hatch--pattern"}
+
+    DEFAULT_CSS = """
+    UnifiedDiffLines > .hatch--pattern {
+        color: $hatch-color;
+    }
+    UnifiedDiffLines {
+        width: 1fr;
+        height: auto;
+    }
+    """
+
+    def __init__(
+        self,
+        rows: Sequence[DiffRow],
+        *,
+        number_digits: int,
+        code_width: int,
+        annotations: bool = True,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        super().__init__(name=name, id=id, classes=classes)
+        self._rows = rows
+        self._number_digits = number_digits
+        self._code_width = code_width
+        self._annotations = annotations
+        self._strip_cache: LRUCache[int, Strip] = LRUCache(maxsize=2000)
+        self._strips_valid_for: int | None = None
+        self._look_key: tuple[str, str | None] | None = None
+        self._look: DiffLook | None = None
+        self._painted: tuple[tuple[int, Region], list[Strip]] | None = None
+
+    # -- content -----------------------------------------------------------------------------------
+
+    @property
+    def rows(self) -> Sequence[DiffRow]:
+        return self._rows
+
+    def set_rows(self, rows: Sequence[DiffRow], *, number_digits: int, code_width: int) -> None:
+        """Show other rows."""
+        self._rows = rows
+        self._number_digits = number_digits
+        self._code_width = code_width
+        self._invalidate_render_cache()
+        self.refresh(layout=True)
+
+    @property
+    def annotations(self) -> bool:
+        """Whether the ``+`` and ``-`` of changed rows show."""
+        return self._annotations
+
+    def set_annotations(self, annotations: bool) -> None:
+        if annotations == self._annotations:
+            return
+        self._annotations = annotations
+        self._invalidate_render_cache()
+        self.refresh(layout=True)
+
+    @property
+    def _annotation_width(self) -> int:
+        return ANNOTATION_WIDTH if self._annotations else COLLAPSED_ANNOTATION_WIDTH
+
+    @property
+    def _gutter_width(self) -> int:
+        return 2 * number_cell_width(self._number_digits) + self._annotation_width
+
+    # -- caches ------------------------------------------------------------------------------------
+
+    def prepare_for_gc_freeze(self) -> None:
+        """Detach the cyclic strip LRU before the permanent generation changes."""
+        # gc-freeze swaps in an acyclic capacity token; renew restores a real cache before next use.
+        self._strip_cache = detach_lru_cache(self._strip_cache)  # ty: ignore[invalid-assignment]
+        self._painted = None
+
+    def after_gc_freeze(self) -> None:
+        """Recreate the strip LRU after the permanent generation changes."""
+        self._strip_cache = renew_lru_cache(self._strip_cache)
+
+    def abort_gc_freeze(self) -> None:
+        """Restore the strip LRU after an incomplete hook pass."""
+        self._strip_cache = renew_lru_cache(self._strip_cache)
+
+    def _invalidate_render_cache(self) -> None:
+        self._strip_cache.clear()
+        self._strips_valid_for = None
+        self._look_key = None
+        self._look = None
+        self._painted = None
+
+    def notify_style_update(self) -> None:
+        """Forget rendered rows when the theme or a CSS variable changes."""
+        super().notify_style_update()
+        self._invalidate_render_cache()
+        self.refresh()
+
+    def _current_look(self) -> DiffLook:
+        if self._look is None:
+            self._look = DiffLook.of(self)
+        return self._look
+
+    # -- rendering ---------------------------------------------------------------------------------
+
+    def get_content_width(self, container: Size, viewport: Size) -> int:
+        return self._gutter_width + self._code_width
+
+    def get_content_height(self, container: Size, viewport: Size, width: int) -> int:
+        return len(self._rows)
+
+    def _begin_frame(self) -> int:
+        """The width to draw rows at, having forgotten the rows that it or the app's look have outdated."""
+        look_key = (self.app.theme, self.app.console.color_system)
+        if look_key != self._look_key:
+            self._invalidate_render_cache()
+            self._look_key = look_key
+        width = self.content_region.width
+        if width != self._strips_valid_for:
+            self._strip_cache.clear()
+            self._strips_valid_for = width
+        return width
+
+    def _safe_text_selection(self) -> Selection | None:
+        try:
+            return self.text_selection
+        except NoScreen:
+            return None
+
+    def render_lines(self, crop: Region) -> list[Strip]:
+        if not self.is_attached:
+            return [Strip.blank(crop.width) for _ in crop.line_range]
+        width = self._begin_frame()
+        selection = self._safe_text_selection()
+        # Line filters and the background need no place in this key: the app pins ``ansi_color``,
+        # so they change only together with the theme, which forgets everything anyway.
+        key = (width, crop)
+        if selection is None and self._painted is not None and self._painted[0] == key:
+            return self._painted[1]
+
+        line_filters = self.get_line_filters()
+        _base_background, background = self.background_colors
+        strips: list[Strip] = []
+        for y in crop.line_range:
+            strip = self._render_row(y, width, selection)
+            for line_filter in line_filters:
+                strip = strip.apply_filter(line_filter, background)
+            if crop.column_span != (0, width):
+                strip = strip.crop(crop.x, crop.x + crop.width)
+            strips.append(strip)
+        self._painted = (key, strips) if selection is None else None
+        return strips
+
+    def render_line(self, y: int) -> Strip:
+        if not self.is_attached:
+            return Strip.blank(max(0, self.size.width))
+        return self._render_row(y, self._begin_frame(), self._safe_text_selection())
+
+    def _render_row(self, y: int, width: int, selection: Selection | None) -> Strip:
+        if width <= 0:
+            return Strip.blank(0)
+        if not 0 <= y < len(self._rows):
+            return Strip.blank(width, self.visual_style.rich_style)
+        selected = None if selection is None else self._selected_characters(selection, y)
+        if selected is not None:
+            return self._draw_row(y, width, selected)
+        strip = self._strip_cache.get(y)
+        if strip is None:
+            strip = self._strip_cache[y] = self._draw_row(y, width, None)
+        return strip
+
+    def _draw_row(self, y: int, width: int, selected: tuple[int, int] | None) -> Strip:
+        row = self._rows[y]
+        look = self._current_look()
+        digits = self._number_digits
+        gutter = (
+            number_cell(row, look, side=Side.BEFORE, digits=digits, edge=True)
+            + number_cell(row, look, side=Side.AFTER, digits=digits, edge=False)
+            # The cell opens with a space. Cut down to it, the annotation is off and the code keeps its distance.
+            + annotation_cell(row, look)[: self._annotation_width]
+        )
+        room = max(1, width - gutter.cell_length)
+        if row.code is None:
+            # A break between hunks: with its cells, hatching from edge to edge.
+            code = Content.styled(HATCH_GLYPH * room, look.hatch)
+        else:
+            code = row.code
+            if code.cell_length < room:
+                code = code.pad_right(room - code.cell_length)
+            code = code.stylize_before(look.line_style(row.kind))
+        line = gutter + code
+        if selected is not None:
+            start, end = selected
+            selection_style = normalize_selection_rich_style(self.screen.get_component_rich_style("screen--selection"))
+            line = line.stylize(VisualStyle.from_rich_style(selection_style), start, len(line) if end == -1 else end)
+        visual_style = self.visual_style
+        strip = Strip(line.render_segments(visual_style), cell_length=line.cell_length)
+        # Offsets count the characters of the whole line, gutter included; see `_code_selection`.
+        return strip.crop(0, width).adjust_cell_length(width, visual_style.rich_style).apply_offsets(0, y)
+
+    # -- selection ---------------------------------------------------------------------------------
+
+    def _selected_characters(self, selection: Selection, y: int) -> tuple[int, int] | None:
+        """The part of row ``y`` to draw as selected. The gutter is never part of a selection."""
+        span = selection.get_span(y)
+        if span is None:
+            return None
+        start, end = span
+        gutter_width = self._gutter_width
+        if end != -1 and end <= gutter_width:
+            return None
+        return max(start, gutter_width), end
+
+    def get_selection(self, selection: Selection) -> tuple[str, str] | None:
+        """The selected code. A break counts as an empty line, which keeps rows and lines in step."""
+        text = "\n".join("" if row.code is None else row.code.plain for row in self._rows)
+        return self._code_selection(selection).extract(text), "\n"
+
+    def _code_selection(self, selection: Selection) -> Selection:
+        """``selection``, which counts from the left edge of the widget, counted from where the code begins."""
+        gutter_width = self._gutter_width
+
+        def in_code(offset: Offset | None) -> Offset | None:
+            return None if offset is None else Offset(max(0, offset.x - gutter_width), offset.y)
+
+        return Selection(in_code(selection.start), in_code(selection.end))

chrys/app/tui/widgets/diff_view/widget.py

@@ -0,0 +1,209 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""DiffView: two texts compared, side by side or as one column."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Generator
+from functools import partial
+from typing import TYPE_CHECKING, NamedTuple
+
+from textual import containers
+from textual.reactive import reactive, var
+
+from chrys.app.tui.widgets.diff_view.cells import ANNOTATION_WIDTH, annotation_cell, number_cell, number_cell_width
+from chrys.app.tui.widgets.diff_view.code import CodeColumn
+from chrys.app.tui.widgets.diff_view.compute import compute_highlighted_lines, compute_hunks
+from chrys.app.tui.widgets.diff_view.gutter import GutterColumn
+from chrys.app.tui.widgets.diff_view.rows import (
+    DiffRow,
+    Hunk,
+    Side,
+    change_counts,
+    code_width,
+    number_width,
+    split_rows,
+    unified_rows,
+)
+from chrys.app.tui.widgets.diff_view.unified import UnifiedDiffLines
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+    from textual.content import Content
+    from textual.widget import Widget
+
+
+class _Layout(NamedTuple):
+    """The rows of one way to show the diff, with the widths their columns need."""
+
+    sides: tuple[list[DiffRow], ...]
+    """One list of rows for a unified diff, two of the same length for a split one."""
+    number_digits: int
+    code_width: int
+
+    @classmethod
+    def of(cls, *sides: list[DiffRow]) -> _Layout:
+        return cls(sides, number_width(*sides), code_width(*sides))
+
+
+class DiffView(containers.VerticalGroup):
+    """The difference between two texts, with syntax highlighting and the edits within lines marked.
+
+    ``split`` chooses between two columns side by side and a single one, and ``annotations`` turns
+    the ``+`` and ``-`` beside changed lines on and off; both can change while the view is mounted.
+
+    Diffing and highlighting take long for a large file. ``await view.prepare()`` does them off the
+    event loop ahead of mounting; a view mounted unprepared does them when it composes.
+    """
+
+    split: reactive[bool] = reactive(True, recompose=True)
+    annotations: var[bool] = var(True, toggle_class="-with-annotations")
+
+    DEFAULT_CSS = """
+    DiffView {
+        width: 1fr;
+        height: auto;
+
+        .diff-group {
+            background: $foreground 4%;
+        }
+
+        .annotations { width: 1; }
+        &.-with-annotations {
+            .annotations { width: auto; }
+        }
+        .code-left {
+            scrollbar-size-vertical: 0;
+        }
+    }
+    """
+
+    def __init__(
+        self,
+        path_before: str,
+        path_after: str,
+        code_before: str,
+        code_after: str,
+        *,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        super().__init__(name=name, id=id, classes=classes)
+        self.path_before = path_before
+        self.path_after = path_after
+        self.code_before = code_before.expandtabs()
+        self.code_after = code_after.expandtabs()
+        self.max_display_lines: int | None = None
+        """Show at most this many rows, and scroll within them."""
+        self.auto_height = False
+        """Be as tall as the diff. ``max_display_lines`` takes precedence."""
+        self.show_scrollbars = True
+        """Without scrollbars, a unified diff is drawn by a single `UnifiedDiffLines`."""
+        self._hunks: list[Hunk] | None = None
+        self._highlighted_lines: tuple[list[Content], list[Content]] | None = None
+        self._layouts: dict[bool, _Layout] = {}
+
+    # -- the diff ----------------------------------------------------------------------------------
+
+    async def prepare(self) -> None:
+        """Work the diff out off the event loop, for the layout that ``split`` selects."""
+        await asyncio.to_thread(self._layout, self.split)
+
+    @property
+    def hunks(self) -> list[Hunk]:
+        if self._hunks is None:
+            self._hunks = compute_hunks(self.code_before, self.code_after)
+        return self._hunks
+
+    @property
+    def counts(self) -> tuple[int, int]:
+        """How many lines were added and how many removed."""
+        return change_counts(self.hunks)
+
+    @property
+    def highlighted_lines(self) -> tuple[list[Content], list[Content]]:
+        """Every line of the old and of the new text."""
+        if self._highlighted_lines is None:
+            self._highlighted_lines = compute_highlighted_lines(
+                self.code_before, self.code_after, self.path_before, self.path_after, self.hunks
+            )
+        return self._highlighted_lines
+
+    def _layout(self, split: bool) -> _Layout:
+        layout = self._layouts.get(split)
+        if layout is None:
+            rows = split_rows if split else unified_rows
+            sides = rows(self.hunks, *self.highlighted_lines)
+            layout = self._layouts[split] = _Layout.of(*(sides if isinstance(sides, tuple) else (sides,)))
+        return layout
+
+    # -- composing ---------------------------------------------------------------------------------
+
+    def watch_annotations(self, annotations: bool) -> None:
+        """The gutter columns collapse through CSS. The single-widget diff draws its own and is told."""
+        for lines in self.query(UnifiedDiffLines):
+            lines.set_annotations(annotations)
+
+    def compose(self) -> ComposeResult:
+        layout = self._layout(self.split)
+        row_count = len(layout.sides[0])
+        if not self.split and not self.show_scrollbars:
+            lines = UnifiedDiffLines(
+                layout.sides[0],
+                number_digits=layout.number_digits,
+                code_width=layout.code_width,
+                annotations=self.annotations,
+                classes="diff-group",
+            )
+            self._set_height(lines, row_count)
+            yield lines
+            return
+
+        group = containers.HorizontalGroup(classes="diff-group")
+        # A row more for the scrollbar under the code.
+        self._set_height(group, row_count + (1 if self.show_scrollbars else 0))
+        with group:
+            if self.split:
+                left, right = layout.sides
+                code_left = yield from self._compose_side(left, layout, Side.BEFORE, classes="code-left")
+                code_right = yield from self._compose_side(right, layout, Side.AFTER, classes="code-right")
+                code_left.scroll_sync = code_right
+                code_right.scroll_sync = code_left
+            else:
+                yield from self._compose_side(layout.sides[0], layout, None, classes="code-right")
+
+    def _compose_side(
+        self, rows: list[DiffRow], layout: _Layout, side: Side | None, *, classes: str
+    ) -> Generator[Widget, None, CodeColumn]:
+        """The gutters and the code of one side, or with ``side`` left out, of a unified diff.
+
+        A side numbers its rows in its own text. A unified diff numbers them in both: the old
+        text first and under the edge bar, then the new.
+        """
+        code = CodeColumn(rows, layout.code_width, classes=classes)
+        if not self.show_scrollbars:
+            code.styles.overflow_x = "hidden"
+            code.styles.overflow_y = "hidden"
+        digits = layout.number_digits
+        if side is None:
+            numbers = [
+                partial(number_cell, side=Side.BEFORE, digits=digits, edge=True),
+                partial(number_cell, side=Side.AFTER, digits=digits, edge=False),
+            ]
+        else:
+            numbers = [partial(number_cell, side=side, digits=digits, edge=True)]
+        code.gutters = [
+            *(GutterColumn(rows, cell, number_cell_width(digits), code) for cell in numbers),
+            GutterColumn(rows, annotation_cell, ANNOTATION_WIDTH, code, classes="annotations"),
+        ]
+        yield from code.gutters
+        yield code
+        return code
+
+    def _set_height(self, widget: UnifiedDiffLines | containers.HorizontalGroup, natural_height: int) -> None:
+        if self.max_display_lines is not None:
+            widget.styles.height = min(natural_height, self.max_display_lines)
+        elif self.auto_height:
+            widget.styles.height = natural_height

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

@@ -0,0 +1,79 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Public editor widget and keymap extension surface."""
+
+from chrys.app.tui.widgets.editor.highlighter import (
+    MARKDOWN_HIGHLIGHT_CHARACTER_CUTOFF,
+    MARKDOWN_HIGHLIGHT_LINE_CUTOFF,
+    MARKDOWN_HIGHLIGHT_PLAIN_STATUS,
+    MarkdownHighlightedTextArea,
+    MarkdownHighlightTheme,
+)
+from chrys.app.tui.widgets.editor.keymaps import (
+    DEFAULT_EDITOR_KEYMAP_REGISTRY,
+    EditorKeymapRegistry,
+    EmacsKeymap,
+    StandardKeymap,
+)
+from chrys.app.tui.widgets.editor.types import (
+    MESSAGE_EDITOR_CHARACTER_LIMIT_STATUS,
+    MESSAGE_EDITOR_MAX_CHARACTERS,
+    EditorBufferSnapshot,
+    EditorCommand,
+    EditorCommandHost,
+    EditorIntent,
+    EditorKeymap,
+    EditorKeyResult,
+    EditorKeyStroke,
+    EditorLocation,
+    EditorMode,
+    EditorRegister,
+    EditorRegisterKind,
+    EditorScrollDirection,
+    EditorStatus,
+    EditorTextRange,
+)
+from chrys.app.tui.widgets.editor.vim import (
+    MAX_VIM_COUNT,
+    VimKeymap,
+    VimMotion,
+    VimOperator,
+    VimState,
+    VimTextObject,
+)
+from chrys.app.tui.widgets.editor.widget import MessageEditor
+
+__all__ = [
+    "DEFAULT_EDITOR_KEYMAP_REGISTRY",
+    "MARKDOWN_HIGHLIGHT_CHARACTER_CUTOFF",
+    "MARKDOWN_HIGHLIGHT_LINE_CUTOFF",
+    "MARKDOWN_HIGHLIGHT_PLAIN_STATUS",
+    "MAX_VIM_COUNT",
+    "MESSAGE_EDITOR_CHARACTER_LIMIT_STATUS",
+    "MESSAGE_EDITOR_MAX_CHARACTERS",
+    "EditorBufferSnapshot",
+    "EditorCommand",
+    "EditorCommandHost",
+    "EditorIntent",
+    "EditorKeyResult",
+    "EditorKeyStroke",
+    "EditorKeymap",
+    "EditorKeymapRegistry",
+    "EditorLocation",
+    "EditorMode",
+    "EditorRegister",
+    "EditorRegisterKind",
+    "EditorScrollDirection",
+    "EditorStatus",
+    "EditorTextRange",
+    "EmacsKeymap",
+    "MarkdownHighlightTheme",
+    "MarkdownHighlightedTextArea",
+    "MessageEditor",
+    "StandardKeymap",
+    "VimKeymap",
+    "VimMotion",
+    "VimOperator",
+    "VimState",
+    "VimTextObject",
+]

chrys/app/tui/widgets/editor/coordinates.py

@@ -0,0 +1,30 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Conversions between editor (row, column) locations and text offsets."""
+
+from __future__ import annotations
+
+from chrys.app.tui.widgets.editor.types import EditorLocation
+
+
+def _lines(text: str) -> list[str]:
+    return text.split("\n")
+
+
+def location_to_offset(text: str, location: EditorLocation) -> int:
+    """The offset of *location* in *text*, clamped to the text."""
+    lines = _lines(text)
+    row = min(max(location[0], 0), len(lines) - 1)
+    column = min(max(location[1], 0), len(lines[row]))
+    return sum(len(line) + 1 for line in lines[:row]) + column
+
+
+def offset_to_location(text: str, offset: int) -> EditorLocation:
+    """The location of *offset* in *text*, clamped to the text."""
+    lines = _lines(text)
+    remaining = min(max(offset, 0), len(text))
+    for row, line in enumerate(lines[:-1]):
+        if remaining <= len(line):
+            return row, remaining
+        remaining -= len(line) + 1
+    return len(lines) - 1, min(remaining, len(lines[-1]))