docagent-cli 0.0.35__py3-none-any.whl

docagent_cli/widgets/diff.py

@@ -0,0 +1,248 @@
+"""Enhanced diff widget for displaying unified diffs."""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING, Any
+
+from textual.containers import Vertical
+from textual.content import Content
+from textual.widgets import Static
+
+from docagent_cli import theme
+from docagent_cli.config import get_glyphs, is_ascii_mode
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+
+
+def compose_diff_lines(
+    diff: str,
+    max_lines: int | None = 100,
+) -> ComposeResult:
+    """Yield per-line Static widgets for a unified diff.
+
+    Each added/removed line gets a CSS class (`.diff-line-added`,
+    `.diff-line-removed`) so background colors are driven by CSS variables
+    and update automatically on theme change.
+
+    Args:
+        diff: Unified diff string.
+        max_lines: Maximum number of diff lines to show (None for unlimited).
+
+    Yields:
+        Static widgets — one per diff line — with appropriate CSS classes.
+    """
+    if not diff:
+        yield Static(Content.styled("No changes detected", "dim"))
+    else:
+        yield from _compose_diff_content(diff, max_lines)
+
+
+def _compose_diff_content(
+    diff: str,
+    max_lines: int | None,
+) -> ComposeResult:
+    """Yield styled diff line widgets for non-empty diff content.
+
+    Args:
+        diff: Non-empty unified diff string.
+        max_lines: Maximum number of diff lines to show (None for unlimited).
+
+    Yields:
+        Static widgets for stats header and individual diff lines.
+    """
+    colors = theme.get_theme_colors()
+    glyphs = get_glyphs()
+    lines = diff.splitlines()
+
+    # Compute stats first
+    additions = sum(
+        1 for ln in lines if ln.startswith("+") and not ln.startswith("+++")
+    )
+    deletions = sum(
+        1 for ln in lines if ln.startswith("-") and not ln.startswith("---")
+    )
+
+    # Stats header
+    stats_parts: list[str | tuple[str, str] | Content] = []
+    if additions:
+        stats_parts.append((f"+{additions}", colors.success))
+    if deletions:
+        if stats_parts:
+            stats_parts.append(" ")
+        stats_parts.append((f"-{deletions}", colors.error))
+    if stats_parts:
+        yield Static(Content.assemble(*stats_parts))
+
+    # Find max line number for width calculation
+    max_line = 0
+    for line in lines:
+        if m := re.match(r"@@ -(\d+)(?:,\d+)? \+(\d+)", line):
+            max_line = max(max_line, int(m.group(1)), int(m.group(2)))
+    width = max(3, len(str(max_line + len(lines))))
+
+    old_num = new_num = 0
+    line_count = 0
+
+    for line in lines:
+        if max_lines and line_count >= max_lines:
+            yield Static(
+                Content.styled(f"\n... ({len(lines) - line_count} more lines)", "dim")
+            )
+            break
+
+        # Skip file headers (--- and +++)
+        if line.startswith(("---", "+++")):
+            continue
+
+        # Handle hunk headers - just update line numbers, don't display
+        if m := re.match(r"@@ -(\d+)(?:,\d+)? \+(\d+)", line):
+            old_num, new_num = int(m.group(1)), int(m.group(2))
+            continue
+
+        # Handle diff lines - use gutter bar instead of +/- prefix
+        content = line[1:] if line else ""
+
+        if line.startswith("-"):
+            # Deletion — red gutter bar, background via CSS
+            yield Static(
+                Content.assemble(
+                    (f"{glyphs.gutter_bar}", f"{colors.error} bold"),
+                    (f"{old_num:>{width}}", "dim"),
+                    f" {content}",
+                ),
+                classes="diff-line-removed",
+            )
+            old_num += 1
+            line_count += 1
+        elif line.startswith("+"):
+            # Addition — green gutter bar, background via CSS
+            yield Static(
+                Content.assemble(
+                    (f"{glyphs.gutter_bar}", f"{colors.success} bold"),
+                    (f"{new_num:>{width}}", "dim"),
+                    f" {content}",
+                ),
+                classes="diff-line-added",
+            )
+            new_num += 1
+            line_count += 1
+        elif line.startswith(" "):
+            # Context line — dim gutter
+            yield Static(
+                Content.assemble(
+                    (f"{glyphs.box_vertical}{old_num:>{width}}", "dim"),
+                    f"  {content}",
+                ),
+            )
+            old_num += 1
+            new_num += 1
+            line_count += 1
+        elif line.strip() == "...":
+            # Truncation marker
+            yield Static(Content.styled("...", "dim"))
+            line_count += 1
+        else:
+            # Unrecognized diff line (e.g., "")
+            yield Static(Content.styled(line, "dim"))
+            line_count += 1
+
+
+class EnhancedDiff(Vertical):
+    """Widget for displaying a unified diff with syntax highlighting."""
+
+    DEFAULT_CSS = """
+    EnhancedDiff {
+        height: auto;
+        padding: 1;
+        background: $surface-darken-1;
+        border: round $primary;
+    }
+
+    EnhancedDiff .diff-title {
+        color: $primary;
+        text-style: bold;
+        margin-bottom: 1;
+    }
+
+    EnhancedDiff .diff-content {
+        height: auto;
+    }
+
+    EnhancedDiff .diff-stats {
+        color: $text-muted;
+        margin-top: 1;
+    }
+    """
+
+    def __init__(
+        self,
+        diff: str,
+        title: str = "Diff",
+        max_lines: int | None = 100,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the diff widget.
+
+        Args:
+            diff: Unified diff string
+            title: Title to display above the diff
+            max_lines: Maximum number of diff lines to show
+            **kwargs: Additional arguments passed to parent
+        """
+        super().__init__(**kwargs)
+        self._diff = diff
+        self._title = title
+        self._max_lines = max_lines
+        self._stats = self._compute_stats()
+
+    def _compute_stats(self) -> tuple[int, int]:
+        """Compute additions and deletions count.
+
+        Returns:
+            Tuple of (additions count, deletions count).
+        """
+        additions = 0
+        deletions = 0
+        for line in self._diff.splitlines():
+            if line.startswith("+") and not line.startswith("+++"):
+                additions += 1
+            elif line.startswith("-") and not line.startswith("---"):
+                deletions += 1
+        return additions, deletions
+
+    def on_mount(self) -> None:
+        """Set border style based on charset mode."""
+        if is_ascii_mode():
+            colors = theme.get_theme_colors(self)
+            self.styles.border = ("ascii", colors.primary)
+
+    def compose(self) -> ComposeResult:
+        """Compose the diff widget layout.
+
+        Yields:
+            Widgets for title, formatted diff content, and stats.
+        """
+        colors = theme.get_theme_colors(self)
+        glyphs = get_glyphs()
+        h = glyphs.box_double_horizontal
+        yield Static(
+            Content.styled(
+                f"{h}{h}{h} {self._title} {h}{h}{h}", f"bold {colors.primary}"
+            ),
+            classes="diff-title",
+        )
+
+        yield from compose_diff_lines(self._diff, self._max_lines)
+
+        additions, deletions = self._stats
+        if additions or deletions:
+            content_parts: list[str | tuple[str, str]] = []
+            if additions:
+                content_parts.append((f"+{additions}", colors.success))
+            if deletions:
+                if content_parts:
+                    content_parts.append(" ")
+                content_parts.append((f"-{deletions}", colors.error))
+            yield Static(Content.assemble(*content_parts), classes="diff-stats")

docagent_cli/widgets/history.py

@@ -0,0 +1,188 @@
+"""Command history manager for input persistence."""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import TYPE_CHECKING
+
+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._load_history()
+
+    def _load_history(self) -> None:
+        """Load history from file."""
+        if not self.history_file.exists():
+            return
+
+        try:
+            with self.history_file.open("r", encoding="utf-8") as f:
+                entries = []
+                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
+                    entries.append(entry if isinstance(entry, str) else str(entry))
+                self._entries = entries[-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)."""
+        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.
+        """
+        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 = ""

docagent_cli/widgets/loading.py

@@ -0,0 +1,177 @@
+"""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 docagent_cli.config import get_glyphs
+from docagent_cli.formatting import format_duration
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+
+
+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._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.set_interval(0.1, self._update_animation)
+
+    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)."""