soothe-cli 0.1.0__py3-none-any.whl

soothe_cli/tui/widgets/history.py

@@ -0,0 +1,221 @@
+"""Command history manager for input persistence."""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import TYPE_CHECKING
+
+from soothe_sdk import GlobalInputHistory
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+class HistoryManager:
+    """Manages command history with file persistence.
+
+    Uses append-only writes for concurrent safety. Multiple agents can
+    safely write to the same history file without corruption.
+    """
+
+    def __init__(self, history_file: Path, max_entries: int = 100) -> None:
+        """Initialize the history manager.
+
+        Args:
+            history_file: Path to the JSON-lines history file
+            max_entries: Maximum number of entries to keep
+        """
+        self.history_file = history_file
+        self.max_entries = max_entries
+        self._entries: list[str] = []
+        self._current_index: int = -1
+        self._temp_input: str = ""
+        self._query: str = ""
+        self._use_global_history_format = self.history_file.name == "history.jsonl"
+        self._global_history_writer: GlobalInputHistory | None = None
+        if self._use_global_history_format:
+            self._global_history_writer = GlobalInputHistory(history_file=str(self.history_file))
+        self._load_history()
+
+    def _load_history(self) -> None:
+        """Load history from file."""
+        if not self.history_file.exists():
+            return
+
+        try:
+            entries: list[str] = []
+            with self.history_file.open("r", encoding="utf-8") as f:
+                for raw_line in f:
+                    line = raw_line.rstrip("\n\r")
+                    if not line:
+                        continue
+                    try:
+                        entry = json.loads(line)
+                    except json.JSONDecodeError:
+                        entry = line
+
+                    text = ""
+                    if isinstance(entry, dict):
+                        text = str(entry.get("text", "")).strip()
+                    elif isinstance(entry, str):
+                        text = entry.strip()
+                    else:
+                        text = str(entry).strip()
+
+                    if not text:
+                        continue
+                    entries.append(text)
+
+            # Keep only latest non-consecutive duplicates to avoid noisy repeats
+            compacted: list[str] = []
+            for text in entries:
+                if compacted and compacted[-1] == text:
+                    continue
+                compacted.append(text)
+            self._entries = compacted[-self.max_entries :]
+        except (OSError, UnicodeDecodeError):
+            logger.warning(
+                "Failed to load history from %s; starting with empty history",
+                self.history_file,
+                exc_info=True,
+            )
+            self._entries = []
+
+    def _append_to_file(self, text: str) -> None:
+        """Append a single entry to history file (concurrent-safe)."""
+        if self._global_history_writer is not None:
+            self._global_history_writer.add(
+                text,
+                thread_id="tui",
+                metadata={"source": "tui"},
+            )
+            return
+        try:
+            self.history_file.parent.mkdir(parents=True, exist_ok=True)
+            with self.history_file.open("a", encoding="utf-8") as f:
+                f.write(json.dumps(text) + "\n")
+        except OSError:
+            logger.warning(
+                "Failed to append history entry to %s",
+                self.history_file,
+                exc_info=True,
+            )
+
+    def _compact_history(self) -> None:
+        """Rewrite history file to remove old entries.
+
+        Only called when entries exceed 2x max_entries to minimize rewrites.
+        """
+        if self._global_history_writer is not None:
+            return
+        try:
+            self.history_file.parent.mkdir(parents=True, exist_ok=True)
+            with self.history_file.open("w", encoding="utf-8") as f:
+                for entry in self._entries:
+                    f.write(json.dumps(entry) + "\n")
+        except OSError:
+            logger.warning(
+                "Failed to compact history file %s",
+                self.history_file,
+                exc_info=True,
+            )
+
+    def add(self, text: str) -> None:
+        """Add a command to history.
+
+        Args:
+            text: The command text to add
+        """
+        text = text.strip()
+        # Skip empty or slash commands
+        if not text or text.startswith("/"):
+            return
+
+        # Skip duplicates of the last entry
+        if self._entries and self._entries[-1] == text:
+            return
+
+        self._entries.append(text)
+
+        # Append to file (fast, concurrent-safe)
+        self._append_to_file(text)
+
+        # Compact only when we have 2x max entries (rare operation)
+        if len(self._entries) > self.max_entries * 2:
+            self._entries = self._entries[-self.max_entries :]
+            self._compact_history()
+
+        self.reset_navigation()
+
+    def get_previous(self, current_input: str, *, query: str = "") -> str | None:
+        """Get the previous history entry matching a substring query.
+
+        The query is captured on the first call of a navigation session
+        (when `_current_index == -1`) and reused for all subsequent calls until
+        `reset_navigation`. Passing a different value on later calls has
+        no effect.
+
+        Args:
+            current_input: Current input text. Saved only on the first call of a
+                navigation session; ignored on subsequent calls.
+            query: Substring to match against history entries.
+                Captured once on the first call of a navigation session.
+
+        Returns:
+            Previous matching entry or `None`.
+        """
+        if not self._entries:
+            return None
+
+        # Save current input and capture query on first navigation
+        if self._current_index == -1:
+            self._temp_input = current_input
+            self._current_index = len(self._entries)
+            self._query = query.strip().lower()
+
+        # Search backwards for matching entry
+        for i in range(self._current_index - 1, -1, -1):
+            if not self._query or self._query in self._entries[i].lower():
+                self._current_index = i
+                return self._entries[i]
+
+        return None
+
+    def get_next(self) -> str | None:
+        """Get the next history entry matching the stored query.
+
+        Uses the query captured by the most recent `get_previous` call.
+
+        Returns:
+            The next matching entry, or the original input when past the newest
+                match.
+
+                `None` if not currently navigating history.
+        """
+        if self._current_index == -1:
+            return None
+
+        # Search forwards for matching entry
+        for i in range(self._current_index + 1, len(self._entries)):
+            if not self._query or self._query in self._entries[i].lower():
+                self._current_index = i
+                return self._entries[i]
+
+        # Return to original input at the end
+        result = self._temp_input
+        self.reset_navigation()
+        return result
+
+    @property
+    def in_history(self) -> bool:
+        """Whether currently navigating history entries."""
+        return self._current_index >= 0
+
+    def reset_navigation(self) -> None:
+        """Reset navigation state."""
+        self._current_index = -1
+        self._temp_input = ""
+        self._query = ""

soothe_cli/tui/widgets/loading.py

@@ -0,0 +1,194 @@
+"""Loading widget with animated spinner for agent activity."""
+
+from __future__ import annotations
+
+from time import time
+from typing import TYPE_CHECKING
+
+from textual.containers import Horizontal
+from textual.content import Content
+from textual.widgets import Static
+
+from soothe_cli.tui.config import get_glyphs
+from soothe_cli.tui.formatting import format_duration
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+    from textual.await_remove import AwaitRemove
+    from textual.timer import Timer
+
+
+class Spinner:
+    """Animated spinner using charset-appropriate frames."""
+
+    def __init__(self) -> None:
+        """Initialize spinner."""
+        self._position = 0
+
+    @property
+    def frames(self) -> tuple[str, ...]:
+        """Get spinner frames from glyphs config."""
+        return get_glyphs().spinner_frames
+
+    def next_frame(self) -> str:
+        """Get next animation frame.
+
+        Returns:
+            The next spinner character in the animation sequence.
+        """
+        frames = self.frames
+        frame = frames[self._position]
+        self._position = (self._position + 1) % len(frames)
+        return frame
+
+    def current_frame(self) -> str:
+        """Get current frame without advancing.
+
+        Returns:
+            The current spinner character.
+        """
+        return self.frames[self._position]
+
+
+class LoadingWidget(Static):
+    """Animated loading indicator with status text and elapsed time.
+
+    Displays: <spinner> Thinking... (3s, esc to interrupt)
+    """
+
+    DEFAULT_CSS = """
+    LoadingWidget {
+        height: auto;
+        padding: 0 1;
+        margin-top: 1;
+    }
+
+    LoadingWidget .loading-container {
+        height: auto;
+        width: 100%;
+    }
+
+    LoadingWidget .loading-spinner {
+        width: auto;
+        color: $primary;
+    }
+
+    LoadingWidget .loading-status {
+        width: auto;
+        color: $primary;
+    }
+
+    LoadingWidget .loading-hint {
+        width: auto;
+        color: $text-muted;
+        margin-left: 1;
+    }
+    """
+
+    def __init__(self, status: str = "Thinking") -> None:
+        """Initialize loading widget.
+
+        Args:
+            status: Initial status text to display
+        """
+        super().__init__()
+        self._status = status
+        self._spinner = Spinner()
+        self._start_time: float | None = None
+        self._spinner_widget: Static | None = None
+        self._status_widget: Static | None = None
+        self._hint_widget: Static | None = None
+        self._animation_timer: Timer | None = None
+        self._paused = False
+        self._paused_elapsed: int = 0
+
+    def compose(self) -> ComposeResult:
+        """Compose the loading widget layout.
+
+        Yields:
+            Widgets for spinner, status text, and hint.
+        """
+        with Horizontal(classes="loading-container"):
+            self._spinner_widget = Static(self._spinner.current_frame(), classes="loading-spinner")
+            yield self._spinner_widget
+
+            self._status_widget = Static(f" {self._status}... ", classes="loading-status")
+            yield self._status_widget
+
+            self._hint_widget = Static("(0s, esc to interrupt)", classes="loading-hint")
+            yield self._hint_widget
+
+    def on_mount(self) -> None:
+        """Start animation on mount."""
+        self._start_time = time()
+        self._animation_timer = self.set_interval(0.1, self._update_animation)
+
+    def on_unmount(self) -> None:
+        """Stop the animation timer when the widget leaves the DOM."""
+        self._stop_timer()
+
+    def remove(self) -> AwaitRemove:
+        """Stop animation before delegating DOM removal to Textual.
+
+        Returns:
+            Awaitable that completes once the widget is removed from the DOM.
+        """
+        self._stop_timer()
+        return super().remove()
+
+    def _stop_timer(self) -> None:
+        """Stop the animation timer if it is running."""
+        if self._animation_timer is not None:
+            self._animation_timer.stop()
+            self._animation_timer = None
+
+    def _update_animation(self) -> None:
+        """Update spinner and elapsed time."""
+        if self._paused:
+            return
+
+        if self._spinner_widget:
+            frame = self._spinner.next_frame()
+            self._spinner_widget.update(frame)
+
+        if self._hint_widget and self._start_time is not None:
+            elapsed = int(time() - self._start_time)
+            self._hint_widget.update(f"({format_duration(elapsed)}, esc to interrupt)")
+
+    def set_status(self, status: str) -> None:
+        """Update the status text.
+
+        Args:
+            status: New status text
+        """
+        self._status = status
+        if self._status_widget:
+            self._status_widget.update(f" {self._status}... ")
+
+    def pause(self, status: str = "Awaiting decision") -> None:
+        """Pause the animation and update status.
+
+        Args:
+            status: Status to show while paused
+        """
+        self._paused = True
+        if self._start_time is not None:
+            self._paused_elapsed = int(time() - self._start_time)
+        self._status = status
+        if self._status_widget:
+            self._status_widget.update(f" {status}... ")
+        if self._hint_widget:
+            self._hint_widget.update(f"(paused at {format_duration(self._paused_elapsed)})")
+        if self._spinner_widget:
+            self._spinner_widget.update(Content.styled(get_glyphs().pause, "dim"))
+
+    def resume(self) -> None:
+        """Resume the animation."""
+        self._paused = False
+        self._status = "Thinking"
+        if self._status_widget:
+            self._status_widget.update(f" {self._status}... ")
+
+    def stop(self) -> None:
+        """Stop the animation (widget will be removed by caller)."""
+        self._stop_timer()