soothe-cli 0.1.0__py3-none-any.whl

soothe_cli/tui/widgets/clipboard.py

@@ -0,0 +1,128 @@
+"""Clipboard utilities for Soothe."""
+
+from __future__ import annotations
+
+import base64
+import logging
+import os
+import pathlib
+from typing import TYPE_CHECKING
+
+from soothe_cli.tui.config import get_glyphs
+
+logger = logging.getLogger(__name__)
+
+if TYPE_CHECKING:
+    from textual.app import App
+
+_PREVIEW_MAX_LENGTH = 40
+
+
+def _copy_osc52(text: str) -> None:
+    """Copy text using OSC 52 escape sequence (works over SSH/tmux)."""
+    encoded = base64.b64encode(text.encode("utf-8")).decode("ascii")
+    osc52_seq = f"\033]52;c;{encoded}\a"
+    if os.environ.get("TMUX"):
+        osc52_seq = f"\033Ptmux;\033{osc52_seq}\033\\"
+
+    with pathlib.Path("/dev/tty").open("w", encoding="utf-8") as tty:
+        tty.write(osc52_seq)
+        tty.flush()
+
+
+def _shorten_preview(texts: list[str]) -> str:
+    """Shorten text for notification preview.
+
+    Returns:
+        Shortened preview text suitable for notification display.
+    """
+    glyphs = get_glyphs()
+    dense_text = glyphs.newline.join(texts).replace("\n", glyphs.newline)
+    if len(dense_text) > _PREVIEW_MAX_LENGTH:
+        return f"{dense_text[: _PREVIEW_MAX_LENGTH - 1]}{glyphs.ellipsis}"
+    return dense_text
+
+
+def copy_selection_to_clipboard(app: App) -> None:
+    """Copy selected text from app widgets to clipboard.
+
+    This queries all widgets for their text_selection and copies
+    any selected text to the system clipboard.
+    """
+    selected_texts = []
+
+    for widget in app.query("*"):
+        if not hasattr(widget, "text_selection") or not widget.text_selection:
+            continue
+
+        selection = widget.text_selection
+
+        if selection.end is None:
+            continue
+
+        try:
+            result = widget.get_selection(selection)
+        except (AttributeError, TypeError, ValueError, IndexError) as e:
+            logger.debug(
+                "Failed to get selection from widget %s: %s",
+                type(widget).__name__,
+                e,
+                exc_info=True,
+            )
+            continue
+
+        if not result:
+            continue
+
+        selected_text, _ = result
+        if selected_text.strip():
+            selected_texts.append(selected_text)
+
+    if not selected_texts:
+        return
+
+    combined_text = "\n".join(selected_texts)
+
+    # Try multiple clipboard methods
+    # Prefer pyperclip/app clipboard first (works reliably on local machines)
+    # OSC 52 is last resort (for SSH/remote where native clipboard unavailable)
+    copy_methods = [app.copy_to_clipboard]
+
+    # Try pyperclip if available (preferred - uses pbcopy on macOS)
+    try:
+        import pyperclip
+
+        copy_methods.insert(0, pyperclip.copy)
+    except ImportError:
+        pass
+
+    # OSC 52 as fallback for remote/SSH sessions
+    copy_methods.append(_copy_osc52)
+
+    for copy_fn in copy_methods:
+        try:
+            copy_fn(combined_text)
+            # Use markup=False to prevent copied text from being parsed as Rich markup
+            app.notify(
+                f'"{_shorten_preview(selected_texts)}" copied',
+                severity="information",
+                timeout=2,
+                markup=False,
+            )
+        except (OSError, RuntimeError, TypeError) as e:
+            logger.debug(
+                "Clipboard copy method %s failed: %s",
+                getattr(copy_fn, "__name__", repr(copy_fn)),
+                e,
+                exc_info=True,
+            )
+            continue
+        else:
+            return
+
+    # If all methods fail, still notify but warn
+    app.notify(
+        "Failed to copy - no clipboard method available",
+        severity="warning",
+        timeout=3,
+    )

soothe_cli/tui/widgets/diff.py

@@ -0,0 +1,240 @@
+"""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 soothe_cli.tui import theme
+from soothe_cli.tui.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")

soothe_cli/tui/widgets/editor.py

@@ -0,0 +1,140 @@
+"""External editor support for composing prompts."""
+
+from __future__ import annotations
+
+import contextlib
+import logging
+import os
+import shlex
+import subprocess  # noqa: S404
+import sys
+import tempfile
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+GUI_WAIT_FLAG: dict[str, str] = {
+    "code": "--wait",
+    "cursor": "--wait",
+    "zed": "--wait",
+    "atom": "--wait",
+    "subl": "-w",
+    "windsurf": "--wait",
+}
+"""Mapping of GUI editor base names to their blocking flag."""
+
+VIM_EDITORS = {"vi", "vim", "nvim"}
+"""Set of vim-family editor base names that receive the `-i NONE` flag."""
+
+
+def resolve_editor() -> list[str] | None:
+    """Resolve editor command from environment.
+
+    Checks $VISUAL, then $EDITOR, then falls back to platform default.
+
+    Returns:
+        Tokenized command list, or `None` if the env var was set but empty after
+            tokenization.
+    """
+    editor = os.environ.get("VISUAL") or os.environ.get("EDITOR")
+    if not editor:
+        if sys.platform == "win32":
+            return ["notepad"]
+        return ["vi"]
+    tokens = shlex.split(editor)
+    return tokens or None
+
+
+def _prepare_command(cmd: list[str], filepath: str) -> list[str]:
+    """Build the full command list with appropriate flags.
+
+    Adds --wait/-w for GUI editors and `-i NONE` for vim-family editors.
+
+    Returns:
+        The complete command list with flags and filepath appended.
+    """
+    cmd = list(cmd)  # copy
+    exe = Path(cmd[0]).stem.lower()
+
+    # Auto-inject wait flag for GUI editors
+    if exe in GUI_WAIT_FLAG:
+        flag = GUI_WAIT_FLAG[exe]
+        if flag not in cmd:
+            cmd.insert(1, flag)
+
+    # Vim workaround: avoid viminfo errors in temp environments
+    if exe in VIM_EDITORS and "-i" not in cmd:
+        cmd.extend(["-i", "NONE"])
+
+    cmd.append(filepath)
+    return cmd
+
+
+def open_in_editor(current_text: str) -> str | None:
+    """Open current_text in an external editor.
+
+    Creates a temp .md file, launches the editor, and reads back the result.
+
+    Args:
+        current_text: The text to pre-populate in the editor.
+
+    Returns:
+        The edited text with normalized line endings, or `None` if the editor
+            exited with a non-zero status, was not found, or the result was
+            empty/whitespace-only.
+    """
+    cmd = resolve_editor()
+    if cmd is None:
+        return None
+
+    tmp_path: str | None = None
+    try:
+        with tempfile.NamedTemporaryFile(
+            suffix=".md",
+            prefix="Soothe-edit-",
+            delete=False,
+            mode="w",
+            encoding="utf-8",
+        ) as tmp:
+            tmp_path = tmp.name
+            tmp.write(current_text)
+
+        full_cmd = _prepare_command(cmd, tmp_path)
+
+        # S603: editor command comes from user's own $EDITOR env var
+        result = subprocess.run(  # noqa: S603
+            full_cmd,
+            stdin=sys.stdin,
+            stdout=sys.stdout,
+            stderr=sys.stderr,
+            check=False,
+        )
+        if result.returncode != 0:
+            logger.warning("Editor exited with code %d: %s", result.returncode, full_cmd)
+            return None
+
+        edited = Path(tmp_path).read_text(encoding="utf-8")
+
+        # Normalize line endings
+        edited = edited.replace("\r\n", "\n").replace("\r", "\n")
+
+        # Most editors append a final newline on save (POSIX convention).
+        # Strip exactly one so the cursor lands on content, not a blank line,
+        # while preserving any intentional trailing newlines the user added.
+        edited = edited.removesuffix("\n")
+
+        # Treat empty result as cancellation
+        if not edited.strip():
+            return None
+
+    except FileNotFoundError:
+        return None
+    except Exception:
+        logger.warning("Editor failed", exc_info=True)
+        return None
+    else:
+        return edited
+    finally:
+        if tmp_path is not None:
+            with contextlib.suppress(OSError):
+                Path(tmp_path).unlink(missing_ok=True)