synapse-cli-agent 0.1.13__py3-none-any.whl

synapse/ui/dialogs/theme_picker.py

@@ -0,0 +1,113 @@
+"""Theme picker dialog — invoked by /theme."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from textual.app import ComposeResult
+
+from synapse.ui.dialogs.base import DialogBase, OptionItem, SectionHeader
+
+
+class ThemePickerDialog(DialogBase):
+    """Browse built-in + custom themes with live preview."""
+
+    _title_icon = "◈"
+
+    def __init__(self, settings: Any, project_root: Any = None) -> None:
+        super().__init__()
+        self._settings = settings
+        self._project_root = project_root
+        try:
+            from synapse.ui.theme import (
+                get_theme,
+                list_themes,
+                reload_theme_catalog,
+            )
+
+            reload_theme_catalog(project_root)
+            self._themes = list_themes()
+            self._current = (getattr(settings, "theme", None) or get_theme().name)
+        except Exception:  # noqa: BLE001
+            self._themes = []
+            self._current = "cursor-dark"
+
+    @property
+    def title_text(self) -> str:
+        return "Select Theme"
+
+    def compose_body(self) -> ComposeResult:
+        yield SectionHeader("Themes")
+        items: list[OptionItem] = []
+        for t in self._themes:
+            kind = _theme_meta(t)
+            items.append(
+                OptionItem(
+                    key=t.name,
+                    label=f"{t.name:22} {t.label}",
+                    detail="",
+                    selected=(t.name == self._current),
+                    meta=kind,
+                )
+            )
+        self._items = items
+
+    def on_mount(self) -> None:
+        super().on_mount()
+        body = self.query_one("#dialog-body")
+        body.set_options(self._items, mark="  ")
+        # Apply the selected theme on mount as a preview.
+        if self._themes:
+            cur = self._current or self._themes[0].name
+            self.on_option_row_clicked(cur)
+
+    def _on_selected(self, key: str | None) -> None:
+        if key:
+            self.dismiss(("theme", key))
+        else:
+            self.dismiss(None)
+
+    def on_option_row_clicked(self, key: str) -> None:
+        """Preview on hover / click before applying."""
+        try:
+            from synapse.ui.theme import set_theme
+        except Exception:  # noqa: BLE001
+            return
+        # Apply preview only (no persist).
+        try:
+            set_theme(key, workspace=self._project_root, persist=False)
+            # Notify app to refresh CSS.
+            app = self.app
+            if hasattr(app, "apply_theme"):
+                app.apply_theme(key, persist=False, announce=False)  # type: ignore[union-attr]
+        except Exception:  # noqa: BLE001
+            pass
+
+
+def _theme_meta(theme: object) -> str:
+    """Right-side hint: ansi | light | dark."""
+    try:
+        from synapse.ui.theme import theme_kind
+
+        return theme_kind(theme)  # type: ignore[arg-type]
+    except Exception:  # noqa: BLE001
+        pass
+    if bool(getattr(theme, "ansi", False)):
+        return "ansi"
+    bg = str(getattr(theme, "bg", "") or "")
+    if bg.strip().casefold() in {"transparent", "ansi_default", "default"}:
+        return "ansi"
+    return "light" if _is_light(bg) else "dark"
+
+
+def _is_light(hex_color: str) -> bool:
+    """Rough luminance check: light bg > 0.5."""
+    c = hex_color.lstrip("#")
+    if len(c) < 6:
+        return False
+    try:
+        r, g, b = int(c[0:2], 16), int(c[2:4], 16), int(c[4:6], 16)
+    except ValueError:
+        return False
+    lum = (0.299 * r + 0.587 * g + 0.114 * b) / 255.0
+    return lum > 0.5

synapse/ui/git_explore/__init__.py

@@ -0,0 +1,31 @@
+"""Git explore: file list + textual-diff-view (Rich fallback)."""
+
+from __future__ import annotations
+
+from synapse.ui.git_explore.engine import (
+    HAS_DIFF_VIEW,
+    fallback_renderable,
+    make_diff_view,
+    status_line,
+)
+from synapse.ui.git_explore.provider import (
+    DIFF_MODES,
+    DiffMode,
+    DiffPayload,
+    language_hint_for_path,
+    load_file_diff,
+)
+from synapse.ui.git_explore.unified import render_unified_diff
+
+__all__ = [
+    "DIFF_MODES",
+    "DiffMode",
+    "DiffPayload",
+    "HAS_DIFF_VIEW",
+    "fallback_renderable",
+    "language_hint_for_path",
+    "load_file_diff",
+    "make_diff_view",
+    "render_unified_diff",
+    "status_line",
+]

synapse/ui/git_explore/engine.py

@@ -0,0 +1,82 @@
+"""Diff engine: textual-diff-view primary, Rich unified fallback."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from rich.text import Text
+
+from synapse.ui.git_explore.provider import DiffPayload
+from synapse.ui.git_explore.unified import render_unified_diff
+
+try:
+    from textual_diff_view import DiffView as _DiffView
+
+    HAS_DIFF_VIEW = True
+except Exception:  # noqa: BLE001
+    _DiffView = None  # type: ignore[assignment,misc]
+    HAS_DIFF_VIEW = False
+
+
+def make_diff_view(
+    payload: DiffPayload,
+    *,
+    split: bool = True,
+    annotations: bool = True,
+    colors: dict[str, str] | None = None,
+    widget_id: str = "ge-diff-view",
+) -> Any:
+    """Build a mountable widget for ``payload``.
+
+    Prefer ``textual_diff_view.DiffView`` when available and content is text.
+    Otherwise return a Rich-backed ``Static``-ready renderable wrapped as payload
+    metadata for the caller to place in a Static (or a prebuilt Static).
+    """
+    colors = colors or {}
+    if payload.error or payload.binary or not HAS_DIFF_VIEW or _DiffView is None:
+        return None
+
+    # Paths are labels only; content comes from strings.
+    path_a = f"a/{payload.path}"
+    path_b = f"b/{payload.path}"
+    if payload.mode == "staged":
+        path_a = f"HEAD/{payload.path}"
+        path_b = f"index/{payload.path}"
+    elif payload.mode == "unstaged":
+        path_a = f"index/{payload.path}"
+        path_b = f"worktree/{payload.path}"
+    else:
+        path_a = f"HEAD/{payload.path}"
+        path_b = f"worktree/{payload.path}"
+
+    return _DiffView(
+        path_a,
+        path_b,
+        payload.text_a or "",
+        payload.text_b or "",
+        split=bool(split),
+        annotations=bool(annotations),
+        auto_split=False,
+        wrap=False,
+        id=widget_id,
+    )
+
+
+def fallback_renderable(payload: DiffPayload, *, colors: dict[str, str] | None = None) -> Any:
+    """Rich Group/Text for cases where DiffView is unavailable or unsuitable."""
+    colors = colors or {}
+    return render_unified_diff(
+        payload,
+        color_meta=colors.get("dim", "#9aa0a6"),
+        color_hunk=colors.get("hunk", "#8ab4f8"),
+        color_add=colors.get("added", "#81c995"),
+        color_del=colors.get("deleted", "#f28b82"),
+        color_ctx=colors.get("fg", "#e8eaed"),
+        color_warn=colors.get("orange", "#f4b183"),
+    )
+
+
+def status_line(*, split: bool, annotations: bool, engine: str) -> Text:
+    layout = "split" if split else "unified"
+    ann = "ann:on" if annotations else "ann:off"
+    return Text(f"{layout} · {ann} · {engine}", style="dim")

synapse/ui/git_explore/provider.py

@@ -0,0 +1,242 @@
+"""Load old/new text for a changed file (working / staged / unstaged)."""
+
+from __future__ import annotations
+
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+DiffMode = Literal["working", "staged", "unstaged"]
+DIFF_MODES: tuple[DiffMode, ...] = ("working", "staged", "unstaged")
+
+# Soft limits for TUI readability (bytes / lines of each side).
+_MAX_BYTES = 512 * 1024
+_MAX_LINES = 8_000
+
+_EXT_LANG: dict[str, str] = {
+    ".py": "python",
+    ".pyi": "python",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".json": "json",
+    ".md": "markdown",
+    ".toml": "toml",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".rs": "rust",
+    ".go": "go",
+    ".java": "java",
+    ".c": "c",
+    ".h": "c",
+    ".cpp": "cpp",
+    ".cc": "cpp",
+    ".cs": "csharp",
+    ".rb": "ruby",
+    ".sh": "bash",
+    ".bash": "bash",
+    ".zsh": "bash",
+    ".css": "css",
+    ".html": "html",
+    ".xml": "xml",
+    ".sql": "sql",
+}
+
+
+@dataclass(frozen=True, slots=True)
+class DiffPayload:
+    """Old/new text for one path under a compare mode."""
+
+    path: str
+    text_a: str
+    text_b: str
+    mode: DiffMode = "working"
+    language_hint: str | None = None
+    binary: bool = False
+    truncated: bool = False
+    error: str | None = None
+    missing_a: bool = False
+    missing_b: bool = False
+
+
+def language_hint_for_path(path: str) -> str | None:
+    ext = Path(path or "").suffix.lower()
+    return _EXT_LANG.get(ext)
+
+
+def _run_git_bytes(args: list[str], *, cwd: Path, timeout: float = 2.0) -> bytes | None:
+    try:
+        proc = subprocess.run(
+            ["git", *args],
+            cwd=str(cwd),
+            capture_output=True,
+            timeout=timeout,
+            check=False,
+        )
+    except Exception:  # noqa: BLE001
+        return None
+    if proc.returncode != 0:
+        return None
+    return proc.stdout or b""
+
+
+def _run_git_text(args: list[str], *, cwd: Path, timeout: float = 2.0) -> str | None:
+    raw = _run_git_bytes(args, cwd=cwd, timeout=timeout)
+    if raw is None:
+        return None
+    try:
+        return raw.decode("utf-8")
+    except UnicodeDecodeError:
+        return raw.decode("utf-8", errors="replace")
+
+
+def _is_binary(data: bytes) -> bool:
+    if not data:
+        return False
+    # NUL in first 8KiB is a strong binary signal.
+    sample = data[:8192]
+    return b"\x00" in sample
+
+
+def _decode_and_cap(data: bytes | None) -> tuple[str, bool, bool]:
+    """Return ``(text, binary, truncated)``."""
+    if data is None:
+        return "", False, False
+    if _is_binary(data):
+        return "", True, False
+    truncated = False
+    body = data
+    if len(body) > _MAX_BYTES:
+        body = body[:_MAX_BYTES]
+        truncated = True
+    try:
+        text = body.decode("utf-8")
+    except UnicodeDecodeError:
+        text = body.decode("utf-8", errors="replace")
+    lines = text.splitlines(keepends=True)
+    if len(lines) > _MAX_LINES:
+        text = "".join(lines[:_MAX_LINES])
+        if not text.endswith("\n"):
+            text += "\n"
+        truncated = True
+    return text, False, truncated
+
+
+def _read_worktree(cwd: Path, path: str) -> tuple[str, bool, bool, bool]:
+    """Return ``(text, binary, truncated, missing)``."""
+    full = cwd / path
+    try:
+        if not full.is_file():
+            return "", False, False, True
+        data = full.read_bytes()
+    except Exception:  # noqa: BLE001
+        return "", False, False, True
+    text, binary, truncated = _decode_and_cap(data)
+    return text, binary, truncated, False
+
+
+def _read_blob(cwd: Path, spec: str) -> tuple[str, bool, bool, bool]:
+    """Read ``git show <spec>``. Returns ``(text, binary, truncated, missing)``."""
+    raw = _run_git_bytes(["show", spec], cwd=cwd, timeout=2.0)
+    if raw is None:
+        return "", False, False, True
+    text, binary, truncated = _decode_and_cap(raw)
+    return text, binary, truncated, False
+
+
+def load_file_diff(
+    cwd: Path | str,
+    path: str,
+    *,
+    mode: DiffMode = "working",
+    is_untracked: bool = False,
+) -> DiffPayload:
+    """Load left/right text for ``path`` under ``mode``.
+
+    Semantics:
+    - working:  HEAD:path  vs worktree
+    - staged:   HEAD:path  vs index (:path)
+    - unstaged: index (:path) vs worktree
+    - untracked: empty vs worktree (any mode)
+    """
+    root = Path(cwd)
+    rel = (path or "").replace("\\", "/").lstrip("./")
+    if not rel:
+        return DiffPayload(
+            path=path or "",
+            text_a="",
+            text_b="",
+            mode=mode,
+            error="empty path",
+        )
+
+    lang = language_hint_for_path(rel)
+    truncated = False
+    binary = False
+
+    if is_untracked:
+        text_b, bin_b, trunc_b, miss_b = _read_worktree(root, rel)
+        binary = bin_b
+        truncated = trunc_b
+        if binary:
+            return DiffPayload(
+                path=rel,
+                text_a="",
+                text_b="",
+                mode=mode,
+                language_hint=lang,
+                binary=True,
+                missing_a=True,
+                missing_b=miss_b,
+            )
+        return DiffPayload(
+            path=rel,
+            text_a="",
+            text_b=text_b,
+            mode=mode,
+            language_hint=lang,
+            truncated=truncated,
+            missing_a=True,
+            missing_b=miss_b,
+        )
+
+    if mode == "staged":
+        text_a, bin_a, trunc_a, miss_a = _read_blob(root, f"HEAD:{rel}")
+        text_b, bin_b, trunc_b, miss_b = _read_blob(root, f":{rel}")
+    elif mode == "unstaged":
+        text_a, bin_a, trunc_a, miss_a = _read_blob(root, f":{rel}")
+        # If not in index, fall back to HEAD as left side.
+        if miss_a:
+            text_a, bin_a, trunc_a, miss_a = _read_blob(root, f"HEAD:{rel}")
+        text_b, bin_b, trunc_b, miss_b = _read_worktree(root, rel)
+    else:  # working
+        text_a, bin_a, trunc_a, miss_a = _read_blob(root, f"HEAD:{rel}")
+        text_b, bin_b, trunc_b, miss_b = _read_worktree(root, rel)
+
+    binary = bin_a or bin_b
+    truncated = trunc_a or trunc_b
+    if binary:
+        return DiffPayload(
+            path=rel,
+            text_a="",
+            text_b="",
+            mode=mode,
+            language_hint=lang,
+            binary=True,
+            truncated=truncated,
+            missing_a=miss_a,
+            missing_b=miss_b,
+        )
+
+    return DiffPayload(
+        path=rel,
+        text_a=text_a,
+        text_b=text_b,
+        mode=mode,
+        language_hint=lang,
+        truncated=truncated,
+        missing_a=miss_a,
+        missing_b=miss_b,
+    )

synapse/ui/git_explore/unified.py

@@ -0,0 +1,85 @@
+"""Fallback unified-diff renderer (Rich Text)."""
+
+from __future__ import annotations
+
+import difflib
+
+from rich.console import Group
+from rich.text import Text
+
+from synapse.ui.git_explore.provider import DiffPayload
+
+
+def render_unified_diff(
+    payload: DiffPayload,
+    *,
+    color_meta: str = "#9aa0a6",
+    color_hunk: str = "#8ab4f8",
+    color_add: str = "#81c995",
+    color_del: str = "#f28b82",
+    color_ctx: str = "#e8eaed",
+    color_warn: str = "#f4b183",
+    context: int = 3,
+) -> Group | Text:
+    """Render a ``DiffPayload`` as colored unified diff lines."""
+    if payload.error:
+        return Text(payload.error, style=color_warn)
+    if payload.binary:
+        return Text(f"binary file: {payload.path}", style=color_meta)
+
+    a_lines = (payload.text_a or "").splitlines(keepends=True)
+    b_lines = (payload.text_b or "").splitlines(keepends=True)
+
+    if not a_lines and not b_lines:
+        if payload.missing_a and payload.missing_b:
+            return Text("file not found on either side", style=color_meta)
+        return Text("no content", style=color_meta)
+
+    if payload.mode == "staged":
+        from_label = f"HEAD/{payload.path}"
+        to_label = f"index/{payload.path}"
+    elif payload.mode == "unstaged":
+        from_label = f"index/{payload.path}"
+        to_label = f"worktree/{payload.path}"
+    else:
+        from_label = f"HEAD/{payload.path}"
+        to_label = f"worktree/{payload.path}"
+
+    rows: list[Text] = []
+    if payload.truncated:
+        rows.append(Text("… truncated for display …", style=color_warn))
+
+    if payload.missing_a and not payload.missing_b:
+        rows.append(Text(f"new file · {payload.mode}", style=color_meta))
+    elif payload.missing_b and not payload.missing_a:
+        rows.append(Text(f"deleted file · {payload.mode}", style=color_meta))
+    else:
+        rows.append(Text(f"{payload.mode} · {payload.path}", style=color_meta))
+
+    diff_iter = difflib.unified_diff(
+        a_lines,
+        b_lines,
+        fromfile=from_label,
+        tofile=to_label,
+        n=max(0, int(context)),
+        lineterm="",
+    )
+    produced = False
+    for line in diff_iter:
+        produced = True
+        raw = line.rstrip("\n")
+        if raw.startswith("+++") or raw.startswith("---"):
+            rows.append(Text(raw, style=color_meta))
+        elif raw.startswith("@@"):
+            rows.append(Text(raw, style=color_hunk))
+        elif raw.startswith("+"):
+            rows.append(Text(raw, style=color_add))
+        elif raw.startswith("-"):
+            rows.append(Text(raw, style=color_del))
+        else:
+            rows.append(Text(raw, style=color_ctx))
+
+    if not produced:
+        rows.append(Text("no differences in this mode", style=color_meta))
+
+    return Group(*rows)