iCode-TUI 0.29.1__py3-none-any.whl

chrys/app/tui/screens/main/settings_persistence.py

@@ -0,0 +1,184 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Debounced user-settings persistence for the main screen.
+
+What accumulates across the debounce window is a patch, not a snapshot. The
+panels edit a few fields at a time against a document other writers share, so
+carrying a whole-document snapshot would let the last edit resurrect values a
+concurrent writer had just changed. A patch merges — two edits inside one
+window become one write, and each write touches only the keys that were
+actually edited.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import logging
+from collections.abc import Callable, Iterable, Mapping
+from typing import Any
+
+from chrys.foundation.config.settings_store import PersistResult, persist
+
+SETTINGS_SAVE_DELAY_SECONDS = 0.25
+SETTINGS_FLUSH_LOCK_TIMEOUT_SECONDS = 0.1
+
+
+def _ignore_written(_result: PersistResult) -> None:
+    return None
+
+
+class SettingsPersistenceQueue:
+    """Persist settings-panel edits without blocking the TUI event loop."""
+
+    def __init__(
+        self,
+        *,
+        notify_failure: Callable[[Exception], None],
+        notify_rejected: Callable[[PersistResult], None],
+        logger: logging.Logger,
+        on_written: Callable[[PersistResult], None] = _ignore_written,
+        save_delay_seconds: float = SETTINGS_SAVE_DELAY_SECONDS,
+        flush_lock_timeout_seconds: float = SETTINGS_FLUSH_LOCK_TIMEOUT_SECONDS,
+    ) -> None:
+        self._notify_failure = notify_failure
+        self._notify_rejected = notify_rejected
+        self._on_written = on_written
+        self._logger = logger
+        self._save_delay_seconds = save_delay_seconds
+        self._flush_lock_timeout_seconds = flush_lock_timeout_seconds
+        self._pending_values: dict[str, Any] = {}
+        self._pending_removals: dict[str, None] = {}
+        self.save_generation = 0
+        self.save_task: asyncio.Task[None] | None = None
+        self.save_persisting = False
+        self.flush_requested = False
+
+    def schedule(self, values: Mapping[str, Any] | None = None, *, remove: Iterable[str] = ()) -> None:
+        """Merge one edit into the pending patch and (re)arm the debounce.
+
+        Within the patch a key is either set or removed, never both — the
+        later instruction wins, exactly as it would have had the two writes
+        gone to disk separately.
+        """
+        for key, value in (values or {}).items():
+            self._pending_values[key] = value
+            self._pending_removals.pop(key, None)
+        for key in remove:
+            self._pending_removals[key] = None
+            self._pending_values.pop(key, None)
+        if not self._pending_values and not self._pending_removals:
+            return
+        self.save_generation += 1
+        self.flush_requested = False
+        task = self.save_task
+        if task is not None and not task.done():
+            return
+        task = asyncio.create_task(self._save_loop())
+        self.save_task = task
+        task.add_done_callback(self._on_save_done)
+
+    async def flush(self, *, notify_on_failure: bool = False) -> None:
+        """Force any pending debounced write to complete immediately.
+
+        ``notify_on_failure`` surfaces an environmental failure (lock, I/O)
+        the way the debounced path does; the teardown flushes keep it off
+        because there is no screen left to show the toast on.
+        """
+        task = self.save_task
+        if not self._pending_values and not self._pending_removals:
+            if task is not None and not task.done():
+                with contextlib.suppress(asyncio.CancelledError):
+                    await task
+            return
+
+        self.flush_requested = True
+        if task is not None and not task.done():
+            if self.save_persisting:
+                with contextlib.suppress(asyncio.CancelledError):
+                    await task
+                return
+            task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await task
+
+        patch = self._take_pending()
+        if patch is None:
+            return
+        self.flush_requested = False
+        values, removals = patch
+        await self.persist_patch(
+            values,
+            removals,
+            lock_timeout=self._flush_lock_timeout_seconds,
+            notify_on_failure=notify_on_failure,
+        )
+
+    async def persist_patch(
+        self,
+        values: Mapping[str, Any],
+        removals: Iterable[str],
+        *,
+        lock_timeout: float | None = None,
+        notify_on_failure: bool = True,
+    ) -> None:
+        """Write one merged patch to the user settings document."""
+        try:
+            if lock_timeout is None:
+                result = await asyncio.to_thread(persist, values, remove=removals)
+            else:
+                result = await asyncio.to_thread(persist, values, remove=removals, lock_timeout=lock_timeout)
+        except Exception as exc:
+            self._logger.warning("Failed to save settings", exc_info=True)
+            if notify_on_failure:
+                self._notify_failure(exc)
+            return
+        if not result.ok:
+            # Not an environmental failure: the panel handed over a value the
+            # store refused, and the whole batch stayed out of the file. Always
+            # surfaced, flush included — silence here is the panel showing an
+            # edit that never landed.
+            self._logger.warning("Settings batch rejected: %s", ", ".join(result.rejected))
+            self._notify_rejected(result)
+            return
+        self._on_written(result)
+
+    def _take_pending(self) -> tuple[dict[str, Any], tuple[str, ...]] | None:
+        if not self._pending_values and not self._pending_removals:
+            return None
+        patch = (dict(self._pending_values), tuple(self._pending_removals))
+        self._pending_values = {}
+        self._pending_removals = {}
+        return patch
+
+    async def _save_loop(self) -> None:
+        while True:
+            observed_generation = self.save_generation
+            if not self.flush_requested:
+                await asyncio.sleep(self._save_delay_seconds)
+                if observed_generation != self.save_generation:
+                    continue
+
+            self.flush_requested = False
+            patch = self._take_pending()
+            if patch is None:
+                return
+
+            values, removals = patch
+            self.save_persisting = True
+            try:
+                await self.persist_patch(values, removals)
+            finally:
+                self.save_persisting = False
+            if not self._pending_values and not self._pending_removals:
+                return
+
+    def _on_save_done(self, task: asyncio.Task[None]) -> None:
+        if task is self.save_task:
+            self.save_task = None
+        try:
+            task.result()
+        except asyncio.CancelledError:
+            pass
+        except Exception:
+            self._logger.debug("Settings save task failed", exc_info=True)

chrys/app/tui/screens/main/shell_mode.py

@@ -0,0 +1,112 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Shell-mode, focus, and paste coordination for the main screen."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+
+from textual.widget import Widget
+
+from chrys.app.tui.screens.main.ports import InputFocusView, ShellModeView
+from chrys.app.tui.screens.main.state import MainScreenState
+from chrys.app.tui.widgets import ASK_USER_INTERACTIVE_CLASS
+from chrys.app.tui.widgets.chat.panel import ChatPanel
+from chrys.app.tui.widgets.sidebar.panel import SidebarPanel
+
+if TYPE_CHECKING:
+    from textual.events import Paste
+
+
+class ShellModeController:
+    """Coordinate shell-mode layout, terminal fullscreen state, focus, and paste guards."""
+
+    def __init__(
+        self,
+        *,
+        state: MainScreenState,
+        shell_view: ShellModeView,
+        focus_view: InputFocusView,
+        set_shell_mode_state: Callable[[bool], None],
+        panel_focus_changed: Callable[[], None],
+        dismiss_suggestions: Callable[[], None],
+        debug: Callable[[str, str], None],
+    ) -> None:
+        self._state = state
+        self._shell_view = shell_view
+        self._focus_view = focus_view
+        self._set_shell_mode_state = set_shell_mode_state
+        # Told after every shell or fullscreen-terminal state change, which
+        # moves what ``keeps_panel_focus`` reports.
+        self._panel_focus_changed = panel_focus_changed
+        self._dismiss_suggestions = dismiss_suggestions
+        self._debug = debug
+
+    def apply(self, active: bool) -> None:
+        """Toggle between chat and shell layout."""
+        if active:
+            self._dismiss_suggestions()
+        self._state.shell.active = active
+        self._panel_focus_changed()
+        if active:
+            self._shell_view.enter_shell_mode()
+        else:
+            self._shell_view.exit_shell_mode()
+        self._debug("ShellMode", "on" if active else "off")
+
+    def exit_on_escape(self) -> None:
+        """Exit shell mode after the terminal reports a double-Escape."""
+        if self._state.shell.active:
+            self._set_shell_mode_state(False)
+
+    def command_executed(self, command: str) -> None:
+        """Record shell command execution for debug sidebar visibility."""
+        self._debug("ShellCommand", command[:60])
+
+    def set_alternate_screen_active(self, active: bool) -> None:
+        """Enter or exit fullscreen terminal pass-through mode."""
+        self._state.shell.fullscreen_terminal = active
+        self._panel_focus_changed()
+        self._shell_view.set_alternate_screen_active(active)
+
+    def exit_on_shell_closed(self) -> None:
+        """Exit shell mode when the shell process exits."""
+        if self._state.shell.active:
+            self._set_shell_mode_state(False)
+
+    def keeps_panel_focus(self) -> bool:
+        """Whether focus that lands on a display-only panel stays there instead of returning to the input."""
+        return self._state.shell.active or self._state.shell.fullscreen_terminal
+
+    def on_descendant_focus(self, widget: object) -> None:
+        """Redirect display-only panel focus back to the input bar."""
+        if self.keeps_panel_focus():
+            return
+        has_class = getattr(widget, "has_class", None)
+        if callable(has_class) and has_class("status-action-btn"):
+            return
+        if isinstance(widget, ChatPanel):
+            return
+        ancestors = getattr(widget, "ancestors_with_self", ())
+        for ancestor in ancestors:
+            if isinstance(ancestor, Widget) and ancestor.has_class(ASK_USER_INTERACTIVE_CLASS):
+                return
+        for ancestor in ancestors:
+            if isinstance(ancestor, ChatPanel | SidebarPanel):
+                self._focus_view.focus_input()
+                return
+
+    def on_paste(self, event: Paste) -> None:
+        """Route image path drops/pastes into the chat input when it is not focused."""
+        # Textual has no public default-prevented accessor; skip events already
+        # consumed by the focused widget so normal text-area pastes do not double insert.
+        # TODO: Replace this private flag if Textual exposes a public accessor.
+        if event._no_default_action:
+            return
+        if self._state.shell.active or self._state.shell.fullscreen_terminal:
+            return
+        if not self._focus_view.insert_paste_payload(event.text):
+            return
+        event.prevent_default()
+        event.stop()

chrys/app/tui/screens/main/state.py

@@ -0,0 +1,289 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Explicit state containers for the main TUI screen."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, field, replace
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from chrys.foundation.config.settings import DEFAULT_WORKSPACE_MRU_MAX_ENTRIES
+from chrys.foundation.events.types import AgentRuntimeDetails, InvocationMessage
+from chrys.foundation.models.execution import ExecutionSnapshot
+from chrys.foundation.platform import safe_getcwd
+from chrys.service.approval.policy import ApprovalMode
+
+if TYPE_CHECKING:
+    import asyncio
+
+    from chrys.foundation.config.settings_store import SettingsHandle
+    from chrys.foundation.events.bus import EventBus
+    from chrys.foundation.events.types import Error
+    from chrys.orchestration.engine.engine import AgentEngine
+    from chrys.service.profiles.agents.registry import AgentProfileRegistry
+    from chrys.service.profiles.models.registry import ModelProfileRegistry
+    from chrys.service.state.store import StateStore
+
+    DeferredTurnEvent = InvocationMessage | Error
+
+
+@dataclass
+class MainScreenServices:
+    """Service handles used by the main-screen controllers."""
+
+    bus: EventBus
+    settings_handle: SettingsHandle | None = None
+    state_store: StateStore | None = None
+    agent_registry: AgentProfileRegistry | None = None
+    model_registry: ModelProfileRegistry | None = None
+    active_model_profile_id: str = ""
+    apply_saved_model_on_restore: bool = True
+    engine_provider: Callable[[], AgentEngine] | None = None
+    workspace_mru_max_entries: int = DEFAULT_WORKSPACE_MRU_MAX_ENTRIES
+
+    def execution(self) -> ExecutionSnapshot:
+        """Read the lease owner, including workflow admission and finalization."""
+        return self.engine_provider().execution() if self.engine_provider is not None else ExecutionSnapshot("idle")
+
+    def execution_busy(self) -> bool:
+        return self.engine_provider().execution_busy() if self.engine_provider is not None else False
+
+    def session_generation(self) -> int:
+        """The engine's session generation; 0 without an engine."""
+        return self.engine_provider().session_generation if self.engine_provider is not None else 0
+
+    def turn_lifecycle_task(self) -> asyncio.Task[None] | None:
+        """The live turn's lifecycle task (run, save, after-turn hooks), if any."""
+        return self.engine_provider().turn_lifecycle_task if self.engine_provider is not None else None
+
+    def was_turn_lifecycle_saved(self, task: asyncio.Task[None]) -> bool:
+        """Whether *task*'s turn completed its final session save successfully; False without an engine."""
+        return self.engine_provider().was_turn_lifecycle_saved(task) if self.engine_provider is not None else False
+
+
+@dataclass
+class RunState:
+    """Live run and loading flags."""
+
+    agent_running: bool = False
+    agent_loading: bool = False
+    has_messages: bool = False
+    generation: int = 0
+    started_at: datetime | None = None
+    # Only the screen writes this: set when a run starts, consumed when it
+    # stops. Backend handlers clear ``agent_running`` before the screen sees
+    # the stop, so that flag cannot tell the screen a run just ended.
+    turn_end_check_pending: bool = False
+
+
+@dataclass
+class RuntimeState:
+    """Active runtime metadata shown by the main screen."""
+
+    profile: str = ""
+    main_usage_source_id: str = ""
+    details: AgentRuntimeDetails = field(default_factory=AgentRuntimeDetails)
+    details_confirmed: bool = False
+    approval_mode: ApprovalMode = ApprovalMode.MANUAL
+    # Set when a Save inside the agent config modal renames the active profile.
+    # The engine switch waits for the modal to close (``on_agent_config_result``):
+    # switching sooner would tear down the live agent while the modal's panels
+    # still reference the old profile object.
+    pending_active_switch: str | None = None
+
+
+@dataclass
+class SessionViewState:
+    """Session lifecycle flags owned by the UI."""
+
+    restoring_session: bool = False
+    creating_new_session: bool = False
+
+
+@dataclass
+class UsageViewState:
+    """Latest usage values rendered by the UI."""
+
+    last_usage_tokens: int = 0
+    last_total_session_tokens: int = 0
+
+
+@dataclass
+class WorkspaceViewState:
+    """Workspace cwd shown by the main screen."""
+
+    current_cwd: str = field(default_factory=safe_getcwd)
+    current_git_branch: str = ""
+    roots: list[str] = field(default_factory=lambda: [safe_getcwd()])
+
+
+@dataclass
+class OverlayState:
+    """Overlay and modal confirmation flags."""
+
+    interrupt_confirm_active: bool = False
+
+
+@dataclass
+class ShellModeState:
+    """Shell-mode layout state."""
+
+    active: bool = False
+    fullscreen_terminal: bool = False
+
+
+@dataclass
+class ProfileSwitchMarkerState:
+    """State for consecutive profile-switch system messages."""
+
+    from_profile: str | None = None
+    to_profile: str | None = None
+    seq: int = 0
+
+
+@dataclass
+class WorkspaceMarkerState:
+    """State for consecutive workspace-change system messages."""
+
+    original_cwd: str | None = None
+    current_cwd: str = field(default_factory=safe_getcwd)
+
+
+@dataclass
+class SubmitCoordinator:
+    """State for a user submit while backend validation is in progress."""
+
+    active: bool = False
+    text: str = ""
+    blocked: bool = False
+    is_retry: bool = False
+
+    def begin(self, text: str, *, is_retry: bool = False) -> None:
+        """Mark a submit as active and clear any previous block decision."""
+        self.active = True
+        self.text = text
+        self.blocked = False
+        self.is_retry = is_retry
+
+    def block(self) -> None:
+        """Record that synchronous backend validation rejected the submit.
+
+        ``EventBus.publish`` awaits its handlers in order, so a rejecting
+        handler has run by the time the submit's publish returns.
+        """
+        self.blocked = True
+
+    def clear(self) -> None:
+        """Reset submit state after the publish phase is complete."""
+        self.active = False
+        self.text = ""
+        self.blocked = False
+        self.is_retry = False
+
+
+@dataclass
+class PendingInjectionState:
+    """Tracks the mid-run injection queued behind the locked input bar.
+
+    At most one injection is pending at a time — the input stays locked
+    until the backend reports a ``UserInjectResult`` for it or the user
+    cancels it with Esc.
+    """
+
+    injection_id: str | None = None
+    text: str = ""
+
+    @property
+    def active(self) -> bool:
+        """Return whether an injection is queued and awaiting its outcome."""
+        return self.injection_id is not None
+
+    def begin(self, injection_id: str, text: str) -> None:
+        """Track a newly queued injection."""
+        self.injection_id = injection_id
+        self.text = text
+
+    def matches(self, injection_id: str | None) -> bool:
+        """Return whether *injection_id* identifies the tracked injection."""
+        return self.injection_id is not None and self.injection_id == injection_id
+
+    def clear(self) -> None:
+        """Stop tracking after the outcome arrived or the user cancelled."""
+        self.injection_id = None
+        self.text = ""
+
+
+@dataclass
+class TurnRenderGate:
+    """Defers fast backend events while the accepted user bubble mounts."""
+
+    active: bool = False
+    _deferred: list[DeferredTurnEvent] = field(default_factory=list)
+
+    def begin(self) -> None:
+        """Start deferring backend events for the current user render."""
+        self.active = True
+        self._deferred.clear()
+
+    def defer(self, event: DeferredTurnEvent) -> None:
+        """Record an event to flush after user rendering completes."""
+        self._deferred.append(event)
+
+    def consume_deferred(self) -> list[DeferredTurnEvent]:
+        """Return deferred messages in arrival order and clear the gate buffer."""
+        deferred = self._deferred
+        self._deferred = []
+        return deferred
+
+    def finish(self, *, rendered: bool) -> None:
+        """Stop deferring, dropping messages when user rendering failed."""
+        self.active = False
+        if not rendered:
+            self._deferred.clear()
+
+    def accept_presentation_attempt(self, attempt_id: str, segment_ids: tuple[str, ...]) -> None:
+        """Commit accepted deferred provisional messages and drop non-canonical ones."""
+        accepted = set(segment_ids)
+        retained: list[DeferredTurnEvent] = []
+        for event in self._deferred:
+            if (
+                not isinstance(event, InvocationMessage)
+                or event.presentation is None
+                or event.presentation.attempt_id != attempt_id
+            ):
+                retained.append(event)
+                continue
+            if event.presentation.segment_id not in accepted:
+                continue
+            retained.append(replace(event, presentation=None))
+        self._deferred = retained
+
+    def reject_presentation_attempt(self, attempt_id: str) -> None:
+        """Drop deferred provisional messages from a rejected attempt."""
+        self._deferred = [
+            event
+            for event in self._deferred
+            if not isinstance(event, InvocationMessage)
+            or event.presentation is None
+            or event.presentation.attempt_id != attempt_id
+        ]
+
+
+@dataclass
+class MainScreenState:
+    """Composite state for the main-screen shell and controllers."""
+
+    run: RunState = field(default_factory=RunState)
+    runtime: RuntimeState = field(default_factory=RuntimeState)
+    session: SessionViewState = field(default_factory=SessionViewState)
+    usage: UsageViewState = field(default_factory=UsageViewState)
+    workspace: WorkspaceViewState = field(default_factory=WorkspaceViewState)
+    overlays: OverlayState = field(default_factory=OverlayState)
+    shell: ShellModeState = field(default_factory=ShellModeState)
+    profile_marker: ProfileSwitchMarkerState = field(default_factory=ProfileSwitchMarkerState)
+    workspace_marker: WorkspaceMarkerState = field(default_factory=WorkspaceMarkerState)
+    submit: SubmitCoordinator = field(default_factory=SubmitCoordinator)
+    render_gate: TurnRenderGate = field(default_factory=TurnRenderGate)
+    pending_injection: PendingInjectionState = field(default_factory=PendingInjectionState)

chrys/app/tui/screens/main/submit_state.py

@@ -0,0 +1,11 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Compatibility import for pending user-submit state."""
+
+from __future__ import annotations
+
+from chrys.app.tui.screens.main.state import SubmitCoordinator
+
+SubmitState = SubmitCoordinator
+
+__all__ = ["SubmitState"]