iCode-TUI 0.29.1__py3-none-any.whl

chrys/app/tui/widgets/chrome/footer.py

@@ -0,0 +1,284 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Deduplicated Footer with display-only binding localization."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from textual.binding import Binding
+from textual.content import Content
+from textual.screen import Screen
+from textual.widgets import Footer
+from textual.widgets._footer import FooterKey, FooterLabel
+
+from chrys.app.tui.binding_display import resolve_binding_display
+from chrys.app.tui.i18n import LocaleController, render_str
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+
+    from chrys.foundation.i18n import Localizer
+
+type _BindingEntry = tuple[str, Binding, bool, str]
+type _BindingSignature = tuple[tuple[_BindingEntry, ...], _BindingEntry | None]
+
+
+@dataclass(frozen=True, slots=True)
+class _FooterKeyDisplay:
+    binding: Binding
+    description_literal: str
+    tooltip_literal: str
+    description_visible: bool
+    tooltip_uses_description: bool
+
+
+class ChrysFooter(Footer):
+    """Avoid recomposing the Footer when only hidden bindings changed.
+
+    Textual publishes a bindings update after every focus transition. Its
+    stock Footer always recomposes in response, and those mount/removal layout
+    messages make a large transcript reflow even when the visible footer is
+    byte-for-byte unchanged.
+    """
+
+    def __init__(self, *, locale_controller: LocaleController | None = None) -> None:
+        self._locale_controller = locale_controller
+        self._visible_binding_signature: _BindingSignature | None = None
+        self._binding_recompose_generation = 0
+        self._binding_recompose_in_progress = False
+        self._binding_recompose_dirty = False
+        self._localization_dirty = False
+        self._rendered_locale_revision: int | None = None
+        self._rendered_key_displays: dict[FooterKey, _FooterKeyDisplay] = {}
+        super().__init__()
+        # Render the screen-level shortcuts in the initial composition. Textual
+        # normally composes an empty Footer and waits for a bindings signal, but
+        # Chrys may push the startup loading dialog before that signal's deferred
+        # recompose runs. The active-screen guard then intentionally strands the
+        # callback until MainScreen resumes, leaving the footer blank throughout
+        # startup. Later binding changes still flow through the signature-based
+        # recompose path below.
+        self._bindings_ready = True
+
+    def on_mount(self) -> None:
+        """Subscribe to bindings and join the bounded locale refresh registry."""
+        super().on_mount()
+        if self._locale_controller is not None:
+            self._locale_controller.register_footer(self)
+            if self._rendered_locale_revision != self._locale_controller.revision:
+                self.invalidate_localization()
+
+    def on_unmount(self) -> None:
+        """Leave the locale registry before Textual releases the Footer."""
+        if self._locale_controller is not None:
+            self._locale_controller.unregister_footer(self)
+        super().on_unmount()
+
+    def invalidate_localization(self) -> None:
+        """Retranslate mounted key children in place, never by recomposition."""
+        if self._locale_controller is None or not self.is_attached:
+            return
+        if self._binding_recompose_in_progress:
+            self._localization_dirty = True
+            return
+        if not self._rendered_key_displays:
+            return
+        self._update_localization_in_place()
+
+    def compose(self) -> ComposeResult:
+        """Localize stock compose nodes while retaining their source Bindings.
+
+        Only display text is rewritten; widths stay ``auto`` so every locale
+        gets its natural key geometry, at startup and after a hot switch.
+        """
+        controller = self._locale_controller
+        if controller is None:
+            yield from super().compose()
+            return
+
+        active_bindings = self.screen.active_bindings
+        visible_by_action: dict[str, tuple[Binding, str]] = {}
+        for _namespace, binding, _enabled, tooltip in active_bindings.values():
+            if binding.show:
+                visible_by_action.setdefault(binding.action, (binding, tooltip))
+
+        palette_entry: tuple[Binding, str] | None = None
+        if self.show_command_palette and self.app.ENABLE_COMMAND_PALETTE:
+            palette_key = self.app.COMMAND_PALETTE_BINDING
+            if active := active_bindings.get(palette_key):
+                _namespace, binding, _enabled, tooltip = active
+                palette_entry = binding, tooltip
+
+        localizer = controller.localizer
+        compose_revision = controller.revision
+        self._rendered_key_displays = {}
+        for child in super().compose():
+            if isinstance(child, FooterKey):
+                is_palette = child.has_class("-command-palette")
+                entry = palette_entry if is_palette else visible_by_action.get(child.action)
+                if entry is not None:
+                    binding, active_tooltip = entry
+                    grouped = child.has_class("-grouped")
+                    tooltip = child.tooltip
+                    display = _FooterKeyDisplay(
+                        binding=binding,
+                        description_literal=child.description,
+                        tooltip_literal=tooltip if isinstance(tooltip, str) else "",
+                        description_visible=bool(child.description),
+                        tooltip_uses_description=(grouped and not active_tooltip)
+                        or (is_palette and not binding.tooltip),
+                    )
+                    self._rendered_key_displays[child] = display
+                    description, tooltip_text = self._resolve_display(display, localizer)
+                    child.description = description
+                    child.tooltip = tooltip_text or None
+            elif isinstance(child, FooterLabel):
+                content = child.content
+                literal = content if isinstance(content, str) else str(content)
+                child.update(Content.from_text(literal, markup=False), layout=False)
+            yield child
+        self._rendered_locale_revision = compose_revision
+
+    def _resolve_display(self, display: _FooterKeyDisplay, localizer: Localizer) -> tuple[str, str]:
+        spec = resolve_binding_display(display.binding)
+        if spec is None:
+            return display.description_literal, display.tooltip_literal
+
+        description_text = render_str(localizer, spec.description.bind())
+        description = description_text if display.description_visible else display.description_literal
+        if spec.tooltip is not None:
+            tooltip = render_str(localizer, spec.tooltip.bind())
+        elif display.tooltip_uses_description:
+            tooltip = description_text
+        else:
+            tooltip = display.tooltip_literal
+        return description, tooltip
+
+    def _update_localization_in_place(self) -> None:
+        controller = self._locale_controller
+        if controller is None:
+            return
+        localizer = controller.localizer
+        for key, display in self._rendered_key_displays.items():
+            if not key.is_attached:
+                continue
+            description, tooltip = self._resolve_display(display, localizer)
+            tooltip_value = tooltip or None
+            if key.description != description:
+                key.description = description
+                key.tooltip = tooltip_value
+                # ``width: auto`` only re-measures the new text on a layout
+                # pass; a repaint alone would keep the old locale's width.
+                key.refresh(layout=True)
+            elif key.tooltip != tooltip_value:
+                key.tooltip = tooltip_value
+        self._rendered_locale_revision = controller.revision
+        self._localization_dirty = False
+
+    def _finish_localization_after_recompose(self) -> None:
+        controller = self._locale_controller
+        if controller is None:
+            return
+        if self._rendered_locale_revision != controller.revision:
+            self._update_localization_in_place()
+        else:
+            self._localization_dirty = False
+
+    def bindings_changed(self, screen: Screen) -> None:
+        """Recompose only when the rendered binding set actually changed."""
+        self._bindings_ready = True
+        # Invalidate every queued callback before deduplication. In particular,
+        # an A -> B -> A bounce must make the pending B callback stale even
+        # though A already matches the last successfully rendered signature.
+        self._binding_recompose_generation += 1
+        generation = self._binding_recompose_generation
+        if self._binding_recompose_in_progress:
+            # The in-flight compose may already have read the prior binding
+            # state. Its rendered result is now uncertain, even when this
+            # signal happens to equal the last committed signature.
+            self._binding_recompose_dirty = True
+            return
+        signature = self._binding_signature(screen)
+        if signature == self._visible_binding_signature and not self._binding_recompose_dirty:
+            return
+        if not screen.app.app_focus:
+            # Preserve the last rendered signature. App focus will call
+            # ``sync_bindings`` so a real background change is not lost.
+            return
+        self._schedule_recompose(screen, generation)
+
+    def _schedule_recompose(self, screen: Screen, generation: int) -> None:
+        """Queue one generation, retaining uncertainty if delivery is lost."""
+        if not self.call_after_refresh(self._recompose_bindings, screen, generation):
+            # A later signal or MainScreen resume must force a retry even when
+            # live bindings equal the last committed signature.
+            self._binding_recompose_dirty = True
+            self._binding_recompose_generation += 1
+
+    async def _recompose_bindings(
+        self,
+        screen: Screen,
+        generation: int,
+    ) -> None:
+        """Commit the dedup signature only after its recompose completes."""
+        if generation != self._binding_recompose_generation:
+            return
+        if (
+            not self.is_attached
+            or screen is not self.screen
+            or screen is not screen.app.screen
+            or not screen.app.app_focus
+        ):
+            return
+        # Binding signals may originate from App/Screen handlers, and
+        # ``call_after_refresh`` preserves that sender context. Footer.compose
+        # binds Footer.compact, so recomposition must run with this Footer as
+        # the active message pump rather than ChrysApp.
+        self._binding_recompose_in_progress = True
+        self._binding_recompose_dirty = False
+        try:
+            with self._context():
+                await self.recompose()
+        except BaseException:
+            self._binding_recompose_dirty = True
+            raise
+        finally:
+            self._binding_recompose_in_progress = False
+        self._finish_localization_after_recompose()
+        if generation == self._binding_recompose_generation and not self._binding_recompose_dirty:
+            # Recompose reads live bindings, so record the same live state
+            # rather than the potentially stale schedule-time signature.
+            self._visible_binding_signature = self._binding_signature(screen)
+            return
+
+        # A synchronous cross-pump publish landed while ``recompose`` was
+        # awaiting. Force one more pass: deduplicating against the last
+        # committed signature is unsafe because the just-rendered state may
+        # differ from it.
+        self._binding_recompose_dirty = True
+        if self.is_attached and screen is self.screen and screen is screen.app.screen and screen.app.app_focus:
+            self._schedule_recompose(screen, self._binding_recompose_generation)
+
+    def sync_bindings(self) -> None:
+        """Apply a binding change that may have occurred while unfocused."""
+        self.bindings_changed(self.screen)
+
+    def _binding_signature(self, screen: Screen) -> _BindingSignature:
+        active = screen.active_bindings
+        visible = tuple(
+            (key, binding, enabled, tooltip)
+            for key, (_namespace, binding, enabled, tooltip) in active.items()
+            if binding.show
+        )
+        command_palette: _BindingEntry | None = None
+        if self.show_command_palette and screen.app.ENABLE_COMMAND_PALETTE:
+            palette_key = screen.app.COMMAND_PALETTE_BINDING
+            if palette := active.get(palette_key):
+                _namespace, binding, enabled, tooltip = palette
+                command_palette = (palette_key, binding, enabled, tooltip)
+        return visible, command_palette
+
+
+__all__ = ["ChrysFooter"]

chrys/app/tui/widgets/chrome/image_paste.py

@@ -0,0 +1,351 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Convert pasted or dropped image paths into chat ``@file`` mentions."""
+
+from __future__ import annotations
+
+import os
+import shlex
+import subprocess
+import time
+import uuid
+from binascii import Error as BinasciiError
+from binascii import unhexlify
+from collections.abc import Sequence
+from contextlib import suppress
+from io import BytesIO
+from pathlib import Path
+from typing import TYPE_CHECKING
+from urllib.error import URLError
+from urllib.parse import urlparse
+from urllib.request import url2pathname
+
+from chrys.app.tui.terminal.title import running_under_textual_web_driver
+from chrys.foundation.platform import get_platform, safe_getcwd
+from chrys.foundation.text.images import IMAGE_MIME_BY_EXTENSION
+from chrys.foundation.text.mentions import format_file_mention
+
+if TYPE_CHECKING:
+    from PIL import Image
+
+    from chrys.service.state.store import StateStore
+
+CLIPBOARD_IMAGE_SESSION_SUBDIR = Path("attachments") / "clipboard"
+_CLIPBOARD_IMAGE_KEEP_COUNT = 100
+_CLIPBOARD_IMAGE_KEEP_BYTES = 512 * 1024 * 1024
+_WINDOWS_CLIPBOARD_GRAB_ATTEMPTS = 5
+_WINDOWS_CLIPBOARD_GRAB_DELAY_SECONDS = 0.02
+_MACOS_CLIPBOARD_IMAGE_CLASSES = ("PNGf", "TIFF", "JPEG", "GIFf")
+# The formats those classes carry; Pillow decodes no other from the clipboard.
+_MACOS_CLIPBOARD_IMAGE_FORMATS = ("PNG", "TIFF", "JPEG", "GIF")
+_MACOS_CLASS_OPEN = chr(0x00AB)
+_MACOS_CLASS_CLOSE = chr(0x00BB)
+
+
+def convert_pasted_image_paths_to_mentions(text: str, cwd: Path) -> str:
+    """Return ``@`` mentions when *text* is a paste/drop payload of image paths.
+
+    Terminal drag-and-drop generally arrives as bracketed paste text. File
+    copy/paste can arrive the same way depending on the terminal and platform.
+    Only path-only payloads are rewritten; normal prose is left untouched.
+    """
+    normalized = text.replace("\r\n", "\n").replace("\r", "\n")
+    paths = _parse_image_path_payload(normalized, cwd=cwd)
+    if not paths:
+        return text
+    return " ".join(format_file_mention(path) for path in paths) + " "
+
+
+def clipboard_image_dir_for_session(state_store: StateStore | None, session_id: str | None) -> Path | None:
+    """Return the session attachment directory for saved clipboard images."""
+    if state_store is None or not session_id:
+        return None
+    return state_store.session_dir(session_id) / CLIPBOARD_IMAGE_SESSION_SUBDIR
+
+
+def save_clipboard_image_to_file(directory: Path | None) -> Path | None:
+    """Save a platform clipboard image into *directory* and return its path.
+
+    Screenshot and image-copy workflows on macOS and Windows can put bitmap
+    data on the clipboard instead of a file path. Textual's terminal paste
+    events only carry text, so the chat input uses this helper from its
+    explicit paste action to bridge bitmap clipboard contents back into
+    Chrys' existing ``@file`` image attachment flow. Browser-host sessions
+    must not read the server machine's clipboard because it is unrelated to
+    the browser client's clipboard and may belong to a different user.
+    """
+    if directory is None or running_under_textual_web_driver():
+        return None
+    info = get_platform()
+    if not (info.is_macos or info.is_windows):
+        return None
+    try:
+        clipboard_payload = _grab_clipboard()
+        return _path_from_clipboard_payload(clipboard_payload, directory=directory)
+    except OSError, RuntimeError, ValueError:
+        return None
+
+
+def _grab_clipboard() -> object:
+    if get_platform().is_macos:
+        return _grab_macos_clipboard_image()
+    return _grab_windows_clipboard()
+
+
+def _grab_windows_clipboard() -> object:
+    """Read the Windows clipboard with retries for transient clipboard-owner races."""
+    from PIL import ImageGrab
+
+    for attempt in range(_WINDOWS_CLIPBOARD_GRAB_ATTEMPTS):
+        try:
+            return ImageGrab.grabclipboard()
+        except OSError:
+            if attempt == _WINDOWS_CLIPBOARD_GRAB_ATTEMPTS - 1:
+                raise
+            time.sleep(_WINDOWS_CLIPBOARD_GRAB_DELAY_SECONDS)
+
+    return None
+
+
+def _grab_macos_clipboard_image() -> object | None:
+    from PIL import Image, UnidentifiedImageError
+
+    for class_code in _MACOS_CLIPBOARD_IMAGE_CLASSES:
+        data = _read_macos_clipboard_class(class_code)
+        if data is None:
+            continue
+        try:
+            with Image.open(BytesIO(data), formats=_MACOS_CLIPBOARD_IMAGE_FORMATS) as image:
+                image.load()
+                return image.copy()
+        except UnidentifiedImageError, OSError, ValueError:
+            continue
+    return None
+
+
+def _read_macos_clipboard_class(class_code: str) -> bytes | None:
+    try:
+        result = subprocess.run(  # noqa: S603 - fixed osascript path and fixed AppleScript class codes.
+            [
+                "/usr/bin/osascript",
+                "-e",
+                f"get the clipboard as {_MACOS_CLASS_OPEN}class {class_code}{_MACOS_CLASS_CLOSE}",
+            ],
+            stdin=subprocess.DEVNULL,
+            capture_output=True,
+            check=False,
+            timeout=2,
+        )
+    except subprocess.SubprocessError, FileNotFoundError, OSError:
+        return None
+    if result.returncode != 0:
+        return None
+    return _decode_macos_clipboard_data(result.stdout)
+
+
+def _decode_macos_clipboard_data(stdout: bytes) -> bytes | None:
+    prefix = b"\xc2\xabdata "
+    suffix = b"\xc2\xbb"
+    start = stdout.find(prefix)
+    if start < 0:
+        return None
+    hex_start = start + len(prefix) + 4
+    end = stdout.find(suffix, hex_start)
+    if end < 0:
+        return None
+    try:
+        return unhexlify(stdout[hex_start:end].strip())
+    except BinasciiError:
+        return None
+
+
+def _path_from_clipboard_payload(payload: object, *, directory: Path) -> Path | None:
+    from PIL import Image
+
+    if isinstance(payload, Image.Image):
+        return _save_clipboard_image(payload, directory=directory)
+    if isinstance(payload, list):
+        return _first_supported_clipboard_file_path(payload)
+    return None
+
+
+def _save_clipboard_image(image: Image.Image, *, directory: Path) -> Path | None:
+    try:
+        directory.mkdir(parents=True, exist_ok=True)
+    except OSError:
+        return None
+
+    path = directory / f"clipboard-image-{uuid.uuid4().hex}.png"
+    converted: Image.Image | None = None
+    try:
+        image_to_save = image
+        if image.mode not in {"1", "L", "LA", "P", "RGB", "RGBA"}:
+            converted = image.convert("RGBA")
+            image_to_save = converted
+        image_to_save.save(path, format="PNG")
+        saved = path.resolve(strict=True)
+        _prune_clipboard_image_dir(directory, keep=saved)
+        return saved
+    except OSError, RuntimeError, ValueError:
+        return None
+    finally:
+        if converted is not None:
+            converted.close()
+
+
+def _prune_clipboard_image_dir(directory: Path, *, keep: Path) -> None:
+    """Bound session/temp clipboard-image buildup while keeping recent pasted files available."""
+    entries: list[tuple[int, int, Path]] = []
+    try:
+        candidates = list(directory.glob("clipboard-image-*.png"))
+    except OSError:
+        return
+    for path in candidates:
+        try:
+            stat = path.stat()
+        except OSError:
+            continue
+        entries.append((stat.st_mtime_ns, stat.st_size, path))
+    entries.sort(key=lambda entry: entry[0], reverse=True)
+
+    total_size = 0
+    for index, (_mtime_ns, size, path) in enumerate(entries):
+        total_size += size
+        if path == keep or (index < _CLIPBOARD_IMAGE_KEEP_COUNT and total_size <= _CLIPBOARD_IMAGE_KEEP_BYTES):
+            continue
+        with suppress(OSError):
+            path.unlink()
+
+
+def _first_supported_clipboard_file_path(paths: Sequence[object]) -> Path | None:
+    cwd = Path(safe_getcwd())
+    for candidate in paths:
+        if not isinstance(candidate, str):
+            continue
+        path = _resolve_supported_image_path(candidate, cwd=cwd)
+        if path is not None:
+            return path
+    return None
+
+
+def _parse_image_path_payload(text: str, *, cwd: Path) -> list[Path]:
+    stripped = text.strip()
+    if not stripped:
+        return []
+
+    for candidates in _candidate_path_groups(stripped):
+        paths = _resolve_supported_image_group(candidates, cwd=cwd)
+        if paths:
+            return paths
+    return []
+
+
+def _candidate_path_groups(text: str) -> list[list[str]]:
+    groups: list[list[str]] = [[text]]
+
+    lines = [line.strip() for line in text.splitlines() if line.strip()]
+    if len(lines) > 1:
+        groups.append(lines)
+
+    split_tokens = text.split()
+    if len(split_tokens) > 1:
+        groups.append(split_tokens)
+
+    if os.name != "nt":
+        shlex_tokens = _shlex_split(text)
+        if shlex_tokens and shlex_tokens not in groups:
+            groups.append(shlex_tokens)
+
+    return groups
+
+
+def _shlex_split(text: str) -> list[str]:
+    try:
+        return shlex.split(text)
+    except ValueError:
+        return []
+
+
+def _resolve_supported_image_group(candidates: list[str], *, cwd: Path) -> list[Path]:
+    paths: list[Path] = []
+    for candidate in candidates:
+        path = _resolve_supported_image_path(candidate, cwd=cwd)
+        if path is None:
+            return []
+        paths.append(path)
+    return paths
+
+
+def _resolve_supported_image_path(candidate: str, *, cwd: Path) -> Path | None:
+    quoted = _candidate_is_quoted(candidate)
+    path_text = _path_text_from_candidate(candidate)
+    if not _path_text_has_supported_image_suffix(path_text) or not _path_text_looks_like_single_path(
+        path_text,
+        quoted=quoted,
+    ):
+        return None
+    try:
+        path = Path(path_text).expanduser()
+    except RuntimeError:
+        return None
+    if path.suffix.lower() not in IMAGE_MIME_BY_EXTENSION:
+        return None
+    if not path.is_absolute():
+        path = cwd / path
+    try:
+        resolved = path.resolve(strict=True)
+    except OSError, ValueError:
+        return None
+    if not resolved.is_file():
+        return None
+    return resolved
+
+
+def _path_text_has_supported_image_suffix(path_text: str) -> bool:
+    if not path_text:
+        return False
+    try:
+        suffix = Path(path_text).suffix.lower()
+    except ValueError:
+        return False
+    return suffix in IMAGE_MIME_BY_EXTENSION
+
+
+def _path_text_looks_like_single_path(path_text: str, *, quoted: bool) -> bool:
+    if not any(char.isspace() for char in path_text):
+        return True
+    try:
+        expanded_path = Path(path_text).expanduser()
+    except RuntimeError, ValueError:
+        return False
+    return (
+        quoted or expanded_path.is_absolute() or path_text.startswith("~") or _path_text_is_windows_absolute(path_text)
+    )
+
+
+def _path_text_is_windows_absolute(path_text: str) -> bool:
+    return (len(path_text) >= 3 and path_text[1:3] in (":\\", ":/")) or path_text.startswith(("\\\\", "//"))
+
+
+def _candidate_is_quoted(candidate: str) -> bool:
+    text = candidate.strip()
+    return len(text) >= 2 and text[0] == text[-1] and text[0] in ("'", '"')
+
+
+def _path_text_from_candidate(candidate: str) -> str:
+    text = candidate.strip()
+    if len(text) >= 2 and text[0] == text[-1] and text[0] in ("'", '"'):
+        text = text[1:-1]
+    try:
+        parsed = urlparse(text)
+    except ValueError:
+        return text
+    if parsed.scheme == "file":
+        path = parsed.path
+        if parsed.netloc and parsed.netloc != "localhost":
+            path = f"//{parsed.netloc}{path}"
+        try:
+            return url2pathname(path)
+        except URLError, ValueError:
+            return ""
+    return text