iCode-TUI 0.29.1__py3-none-any.whl

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

@@ -0,0 +1,161 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""A column of cells beside the code: line numbers, or the ``+`` and ``-`` of changed lines."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+from typing import TYPE_CHECKING, ClassVar, Self
+
+from textual.cache import LRUCache
+from textual.geometry import Region, Size
+from textual.strip import Strip
+from textual.widget import Widget
+
+from chrys.app.tui.support.gc_freeze import detach_lru_cache, renew_lru_cache
+from chrys.app.tui.widgets.diff_view.palette import DiffLook
+
+if TYPE_CHECKING:
+    from textual.content import Content
+
+    from chrys.app.tui.widgets.diff_view.code import CodeColumn
+    from chrys.app.tui.widgets.diff_view.rows import DiffRow
+
+type GutterCell = Callable[[DiffRow, DiffLook], Content]
+"""Draws what a gutter shows for one row. See `chrys.app.tui.widgets.diff_view.cells`."""
+
+
+class GutterColumn(Widget):
+    """One cell per row, in step with a `CodeColumn`.
+
+    The gutter does not scroll. It reads the position of its code column and draws the cells of
+    the rows that column shows, and the code column refreshes it when the position changes.
+    """
+
+    COMPONENT_CLASSES: ClassVar[set[str]] = {"hatch--pattern"}
+
+    DEFAULT_CSS = """
+    GutterColumn > .hatch--pattern {
+        color: $hatch-color;
+    }
+    GutterColumn {
+        width: auto;
+        height: 1fr;
+    }
+    """
+
+    def __init__(
+        self,
+        rows: Sequence[DiffRow],
+        cell: GutterCell,
+        cell_width: int,
+        code_column: CodeColumn,
+        *,
+        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.code_column = code_column
+        self._cell = cell
+        self._cell_width = cell_width
+        self._strip_cache: LRUCache[int, Strip] = LRUCache(maxsize=500)
+        self._look_key: tuple[str, str | None] | None = None
+        self._look: DiffLook | None = None
+        self._painted: tuple[tuple[int, int, Region], list[Strip]] | None = None
+
+    # -- 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._look_key = None
+        self._look = None
+        self._painted = None
+
+    def notify_style_update(self) -> None:
+        """Forget rendered cells when the theme or a CSS variable changes."""
+        super().notify_style_update()
+        self._invalidate_render_cache()
+        self.refresh()
+
+    def refresh(self, *regions: Region, repaint: bool = True, layout: bool = False, recompose: bool = False) -> Self:
+        """Whoever asks for a refresh knows of a change that the scroll position does not show."""
+        self._painted = None
+        return super().refresh(*regions, repaint=repaint, layout=layout, recompose=recompose)
+
+    # -- rendering ---------------------------------------------------------------------------------
+
+    def get_content_width(self, container: Size, viewport: Size) -> int:
+        return self._cell_width
+
+    def _window(self) -> tuple[int, int]:
+        """The first row on display, and how many: never more than the code column has lines for.
+
+        The code column may be the shorter of the two by the scrollbar under it. Cells drawn
+        beside that scrollbar would belong to rows the column is not showing.
+        """
+        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
+        code_column = self.code_column
+        return round(code_column.scroll_offset.y), code_column.scrollable_content_region.height
+
+    def render_lines(self, crop: Region) -> list[Strip]:
+        if not self.is_attached:
+            return [Strip.blank(crop.width) for _ in crop.line_range]
+        first_row, height = self._window()
+        key = (first_row, height, crop)
+        if self._painted is not None and self._painted[0] == key:
+            return self._painted[1]
+
+        width = self._cell_width
+        line_filters = self.get_line_filters()
+        _base_background, background = self.background_colors
+        strips: list[Strip] = []
+        for y in crop.line_range:
+            strip = self._render_cell(first_row + y) if y < height else self._blank()
+            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)
+        return strips
+
+    def render_line(self, y: int) -> Strip:
+        if not self.is_attached:
+            return Strip.blank(self._cell_width)
+        first_row, height = self._window()
+        return self._render_cell(first_row + y) if y < height else self._blank()
+
+    def _blank(self) -> Strip:
+        return Strip.blank(self._cell_width, self.visual_style.rich_style)
+
+    def _render_cell(self, index: int) -> Strip:
+        if not 0 <= index < len(self.rows):
+            return self._blank()
+        strip = self._strip_cache.get(index)
+        if strip is None:
+            if self._look is None:
+                self._look = DiffLook.of(self)
+            visual_style = self.visual_style
+            cell = self._cell(self.rows[index], self._look)
+            strip = Strip(cell.render_segments(visual_style), cell_length=cell.cell_length)
+            strip = self._strip_cache[index] = strip.adjust_cell_length(self._cell_width, visual_style.rich_style)
+        return strip

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

@@ -0,0 +1,77 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""The unified diff of a file-tool card in the chat."""
+
+from __future__ import annotations
+
+import asyncio
+from contextlib import suppress
+
+from textual.geometry import Region
+
+from chrys.app.tui.widgets.diff_view.compute import compute_highlighted_lines, compute_hunks
+from chrys.app.tui.widgets.diff_view.rows import DiffRow, code_width, number_width, unified_rows
+from chrys.app.tui.widgets.diff_view.unified import UnifiedDiffLines
+
+
+class InlineUnifiedDiffLines(UnifiedDiffLines):
+    """A `UnifiedDiffLines` that works its rows out of two texts itself.
+
+    `DiffView` is the viewer with everything. A card in the chat shows a few lines of a unified
+    diff and nothing else, so it mounts this one widget instead of a view around it, and
+    highlights no further into a file than the diff goes.
+    """
+
+    def __init__(
+        self,
+        path_before: str,
+        path_after: str,
+        code_before: str,
+        code_after: str,
+        *,
+        max_display_lines: int | None = None,
+        auto_height: bool = False,
+        annotations: bool = True,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = "diff-group",
+    ) -> None:
+        super().__init__((), number_digits=1, code_width=1, annotations=annotations, 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 = max_display_lines
+        self.auto_height = auto_height
+        self._prepared = False
+
+    async def prepare(self) -> None:
+        """Work the rows out off the event loop. Await this before mounting."""
+        if self._prepared:
+            return
+        rows, number_digits, widest_code = await asyncio.to_thread(self._compute_rows)
+        self.set_rows(rows, number_digits=number_digits, code_width=widest_code)
+        if self.max_display_lines is not None:
+            self.styles.height = min(len(rows), self.max_display_lines)
+        elif self.auto_height:
+            self.styles.height = len(rows)
+        self._prepared = True
+
+    def _compute_rows(self) -> tuple[list[DiffRow], int, int]:
+        hunks = compute_hunks(self.code_before, self.code_after)
+        before, after = compute_highlighted_lines(
+            self.code_before, self.code_after, self.path_before, self.path_after, hunks, hunks_only=True
+        )
+        rows = unified_rows(hunks, before, after)
+        return rows, number_width(rows), code_width(rows)
+
+    def prewarm_visible_rows(self) -> None:
+        """Render the rows on display ahead of the first paint, so that it finds them cached."""
+        with suppress(Exception):
+            if not self._prepared or not self.is_attached:
+                return
+            width = self.content_region.width or self.size.width
+            height = self.size.height
+            if width <= 0 or height <= 0:
+                return
+            self.render_lines(Region(0, 0, width, min(height, len(self.rows))))

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

@@ -0,0 +1,87 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""The colors of a diff, and how the app's present look selects among them."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+from chrys.app.tui.widgets import hatch_style
+from chrys.app.tui.widgets.diff_view.rows import RowKind
+
+if TYPE_CHECKING:
+    from textual.style import Style as VisualStyle
+    from textual.widget import Widget
+
+REMOVED_EMPHASIS = "on $error 40%"
+"""Marks the characters of a removed line that the line replacing it does not have."""
+ADDED_EMPHASIS = "on $success 40%"
+"""Marks the characters of an added line that the line it replaces did not have."""
+
+
+@dataclass(frozen=True, slots=True)
+class DiffPalette:
+    """Styles for a row's line number, the edge bar ahead of it, and the line of code, by row kind."""
+
+    number: Mapping[RowKind, str]
+    edge: Mapping[RowKind, str]
+    line: Mapping[RowKind, str]
+    line_in_256_colors: Mapping[RowKind, str] = field(default_factory=dict)
+    """Backgrounds to use instead on a 256-color terminal, where the nearest match Rich would pick
+    for a subtle tint comes out grey. These are exact xterm colors."""
+
+    def line_style(self, kind: RowKind, color_system: str | None) -> str:
+        if color_system == "256" and kind in self.line_in_256_colors:
+            return self.line_in_256_colors[kind]
+        return self.line.get(kind, "")
+
+
+DARK = DiffPalette(
+    number={
+        RowKind.ADDED: "$text-success on #1f4d2a",
+        RowKind.REMOVED: "$text-error on #5a2628",
+        RowKind.CONTEXT: "$foreground 30%",
+    },
+    edge={
+        RowKind.ADDED: "$success on #1f4d2a",
+        RowKind.REMOVED: "$error on #5a2628",
+        RowKind.CONTEXT: "$foreground 15%",
+    },
+    line={RowKind.ADDED: "on #243f30", RowKind.REMOVED: "on #512b35"},
+    line_in_256_colors={RowKind.ADDED: "on #005F00", RowKind.REMOVED: "on #5F0000"},
+)
+
+LIGHT = DiffPalette(
+    number={
+        RowKind.ADDED: "#1f7a3a on #D4ECD9",
+        RowKind.REMOVED: "#8f1f25 on #F0D4D8",
+        RowKind.CONTEXT: "$foreground 30%",
+    },
+    edge={
+        RowKind.ADDED: "#2E8B57 on #D4ECD9",
+        RowKind.REMOVED: "#C75261 on #F0D4D8",
+        RowKind.CONTEXT: "$foreground 15%",
+    },
+    line={RowKind.ADDED: "on #d8f0dc", RowKind.REMOVED: "on #F8E8EA"},
+)
+
+
+@dataclass(frozen=True, slots=True)
+class DiffLook:
+    """What drawing a row depends on beyond the row: resolved once per look of the app, not per row."""
+
+    palette: DiffPalette
+    color_system: str | None
+    hatch: VisualStyle
+
+    @classmethod
+    def of(cls, widget: Widget) -> DiffLook:
+        """The look for ``widget``, which is mounted and declares the ``hatch--pattern`` component."""
+        theme = widget.app.current_theme
+        palette = DARK if theme is None or theme.dark else LIGHT
+        return cls(palette, widget.app.console.color_system, hatch_style(widget))
+
+    def line_style(self, kind: RowKind) -> str:
+        return self.palette.line_style(kind, self.color_system)

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

@@ -0,0 +1,24 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Structural protocols for diff widgets.
+
+Kept dependency-free so capability checks stay importable without pulling
+in the heavyweight widget modules of this package.
+"""
+
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class SupportsPrepare(Protocol):
+    """Diff widget that pre-computes expensive render state off-thread.
+
+    Await ``prepare()`` before mounting so ``compose()`` finds cached
+    results instantly instead of blocking the event loop on Pygments
+    highlighting and ``SequenceMatcher`` diffing. Implemented by
+    ``DiffView`` and ``InlineUnifiedDiffLines``.
+    """
+
+    async def prepare(self) -> None: ...

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

@@ -0,0 +1,138 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""The rows of a diff: what each line on display stands for.
+
+A diff is computed as hunks of line opcodes and shown as rows. A row says what kind of line it is,
+which line of the old and of the new text it shows, and carries the highlighted code. Everything a
+renderer needs to draw a line is on its row, so the widgets share one list of rows and nothing has
+to be kept in step with it.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Sequence
+from dataclasses import dataclass
+from enum import Enum
+from itertools import zip_longest
+
+from textual.content import Content
+
+type Opcode = tuple[str, int, int, int, int]
+"""One `difflib` opcode: what happened to lines ``[i1, i2)`` of the old text and ``[j1, j2)`` of the new."""
+type Hunk = Sequence[Opcode]
+"""A run of changes with the unchanged lines around it."""
+
+
+class Side(Enum):
+    """One of the two texts a diff compares."""
+
+    BEFORE = "before"
+    AFTER = "after"
+
+
+class RowKind(Enum):
+    """What a row shows."""
+
+    CONTEXT = "context"
+    ADDED = "added"
+    REMOVED = "removed"
+    FILLER = "filler"
+    """Nothing on this side of a split diff: the line across from it has no counterpart."""
+    BREAK = "break"
+    """Stands for the unchanged lines left out between two hunks, across the whole width of the diff."""
+
+
+@dataclass(frozen=True, slots=True)
+class DiffRow:
+    """One line of a diff on display."""
+
+    kind: RowKind
+    code: Content | None = None
+    before: int | None = None
+    """The line's number in the old text, counted from one."""
+    after: int | None = None
+    """The line's number in the new text, counted from one."""
+
+    def number(self, side: Side) -> int | None:
+        return self.before if side is Side.BEFORE else self.after
+
+    @property
+    def is_placeholder(self) -> bool:
+        """Whether the row stands where no line is. Every column draws such a row as hatching."""
+        return self.kind in _PLACEHOLDERS
+
+
+_PLACEHOLDERS = frozenset({RowKind.FILLER, RowKind.BREAK})
+
+BREAK_ROW = DiffRow(RowKind.BREAK)
+FILLER_ROW = DiffRow(RowKind.FILLER)
+
+
+def _removed_rows(before: Sequence[Content], start: int, end: int) -> list[DiffRow]:
+    return [DiffRow(RowKind.REMOVED, before[index], before=index + 1) for index in range(start, end)]
+
+
+def _added_rows(after: Sequence[Content], start: int, end: int) -> list[DiffRow]:
+    return [DiffRow(RowKind.ADDED, after[index], after=index + 1) for index in range(start, end)]
+
+
+def unified_rows(hunks: Iterable[Hunk], before: Sequence[Content], after: Sequence[Content]) -> list[DiffRow]:
+    """Lay hunks out in one column: within a change, the removed lines and then the added ones."""
+    rows: list[DiffRow] = []
+    for hunk in hunks:
+        if rows:
+            rows.append(BREAK_ROW)
+        for tag, i1, i2, j1, j2 in hunk:
+            if tag == "equal":
+                rows.extend(
+                    DiffRow(RowKind.CONTEXT, before[i1 + offset], i1 + offset + 1, j1 + offset + 1)
+                    for offset in range(i2 - i1)
+                )
+            else:
+                rows.extend(_removed_rows(before, i1, i2))
+                rows.extend(_added_rows(after, j1, j2))
+    return rows
+
+
+def split_rows(
+    hunks: Iterable[Hunk], before: Sequence[Content], after: Sequence[Content]
+) -> tuple[list[DiffRow], list[DiffRow]]:
+    """Lay hunks out in two columns of equal length, the old text on the left and the new on the right.
+
+    Within a change the removed and the added lines pair off from the top, and the side that runs
+    out first is filled up. Each side shows context in its own highlighting: the same text may
+    read differently once a change further up opened a string or a comment.
+    """
+    left: list[DiffRow] = []
+    right: list[DiffRow] = []
+    for hunk in hunks:
+        if left:
+            left.append(BREAK_ROW)
+            right.append(BREAK_ROW)
+        for tag, i1, i2, j1, j2 in hunk:
+            if tag == "equal":
+                left.extend(DiffRow(RowKind.CONTEXT, before[index], before=index + 1) for index in range(i1, i2))
+                right.extend(DiffRow(RowKind.CONTEXT, after[index], after=index + 1) for index in range(j1, j2))
+            else:
+                pairs = zip_longest(_removed_rows(before, i1, i2), _added_rows(after, j1, j2), fillvalue=FILLER_ROW)
+                for removed, added in pairs:
+                    left.append(removed)
+                    right.append(added)
+    return left, right
+
+
+def change_counts(hunks: Iterable[Hunk]) -> tuple[int, int]:
+    """How many lines the hunks add and how many they remove."""
+    changes = [opcode for hunk in hunks for opcode in hunk if opcode[0] != "equal"]
+    return sum(j2 - j1 for _, _, _, j1, j2 in changes), sum(i2 - i1 for _, i1, i2, _, _ in changes)
+
+
+def number_width(*row_lists: Sequence[DiffRow]) -> int:
+    """The digits needed for the largest line number among the rows."""
+    numbers = (number for rows in row_lists for row in rows for number in (row.before, row.after) if number)
+    return len(str(max(numbers, default=0)))
+
+
+def code_width(*row_lists: Sequence[DiffRow]) -> int:
+    """The width in cells of the longest line of code among the rows, and never less than one."""
+    return max((row.code.cell_length for rows in row_lists for row in rows if row.code is not None), default=1) or 1