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

synapse/ui/dialogs/mcp_panel.py

@@ -0,0 +1,407 @@
+"""MCP server & tool selection panel — invoked by /mcp or F5.
+
+Shows servers and their discovered tools with checkboxes.  Select which tools
+to enable per server, then save to the config file so only those tools are
+loaded on next startup / reload.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+
+from synapse.ui.dialogs.base import DialogBase, OptionItem
+
+# Wider dialog with visible scrollbar for potentially long tool lists.
+MCP_DIALOG_CSS = """
+McpPanelDialog {
+    align: center middle;
+    background: $theme-bg 60%;
+}
+McpPanelDialog > #dialog-window {
+    width: 72;
+    height: auto;
+    max-height: 38;
+    background: $theme-bg;
+    border: round $theme-user;
+    border-title-color: $theme-fg;
+    border-title-background: $theme-top;
+    border-title-style: bold;
+    border-title-align: left;
+    border-subtitle-color: $theme-muted;
+    border-subtitle-align: right;
+    padding: 0;
+    layout: vertical;
+}
+McpPanelDialog #dialog-body {
+    height: auto;
+    max-height: 32;
+    min-height: 3;
+    width: 1fr;
+    padding: 0 1;
+    background: $theme-bg;
+    overflow-y: auto;
+    overflow-x: hidden;
+    scrollbar-size: 1 2;
+    scrollbar-background: $theme-bar;
+    scrollbar-color: $theme-dim;
+    scrollbar-background-hover: $theme-bar;
+    scrollbar-color-hover: $theme-user;
+    scrollbar-background-active: $theme-bar;
+    scrollbar-color-active: $theme-user;
+}
+McpPanelDialog DialogBody OptionRow {
+    height: 1;
+    width: 1fr;
+    color: $theme-dim;
+    padding: 0 1;
+    background: $theme-bg;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+McpPanelDialog DialogBody OptionRow.-selected {
+    color: $theme-user;
+    background: $theme-bar;
+    text-style: bold;
+}
+McpPanelDialog DialogBody SectionHeader {
+    height: 1;
+    width: 1fr;
+    color: $theme-orange;
+    padding: 0 1;
+    text-style: bold;
+}
+"""
+
+
+def _resolve_mcp_config_path(settings: Any, project_root: Path | None = None) -> Path | None:
+    """Find the mcp.json file to write to (prefer explicit → project → user)."""
+    explicit: str | None = getattr(settings, "mcp_config_path", None)
+    if explicit:
+        p = Path(explicit).expanduser()
+        if p.is_file():
+            return p
+        return p
+
+    from synapse.settings.config_paths import mcp_config_paths
+
+    existing = mcp_config_paths(project_root)
+    if existing:
+        return existing[-1]
+
+    from synapse.settings.config_paths import project_config_dir
+
+    return project_config_dir(project_root) / "mcp.json"
+
+
+def _save_include_tools_to_config(
+    settings: Any,
+    server_name: str,
+    include_tools: list[str] | None,
+    project_root: Path | None = None,
+) -> Path | None:
+    """Write ``include_tools`` for one server into the mcp.json config file.
+
+    Returns the path written, or None on failure.
+    """
+    config_path = _resolve_mcp_config_path(settings, project_root)
+    if config_path is None:
+        return None
+
+    try:
+        if config_path.is_file():
+            data = json.loads(config_path.read_text(encoding="utf-8"))
+        else:
+            data = {}
+    except (json.JSONDecodeError, OSError):
+        data = {}
+
+    if not isinstance(data, dict):
+        data = {}
+
+    servers: list[dict[str, Any]] = []
+    if isinstance(data.get("servers"), list):
+        servers = data["servers"]
+    elif isinstance(data, list):
+        servers = data
+
+    for s in servers:
+        if isinstance(s, dict) and s.get("name") == server_name:
+            if include_tools is None or len(include_tools) == 0:
+                s.pop("include_tools", None)
+            else:
+                s["include_tools"] = include_tools
+            break
+    else:
+        return None
+
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+
+    if isinstance(data.get("servers"), list):
+        data["servers"] = servers
+        config_path.write_text(
+            json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8"
+        )
+    elif isinstance(data, list):
+        config_path.write_text(
+            json.dumps(servers, indent=2, ensure_ascii=False), encoding="utf-8"
+        )
+
+    return config_path
+
+
+class McpPanelDialog(DialogBase):
+    """List MCP servers and their tools; toggle per-tool; save to config."""
+
+    DEFAULT_CSS = MCP_DIALOG_CSS
+    BINDINGS = [
+        *DialogBase.BINDINGS,
+        Binding("space", "toggle_check", "Toggle", show=False, priority=True),
+        Binding("s", "save", "Save", show=False, priority=True),
+        Binding("r", "reload", "Reload", show=False, priority=True),
+        Binding("d", "toggle_server", "Toggle server", show=False, priority=True),
+    ]
+    _title_icon = ""
+    _title_keys = (
+        "\u2191\u2193 move \u00b7 space/\u21b5 fold/toggle \u00b7 d toggle server \u00b7"
+        " ctrl+a all \u00b7 s save \u00b7 r reload \u00b7 esc close"
+    )
+
+    def __init__(
+        self,
+        settings: Any,
+        *,
+        project_root: Any = None,
+        on_save: Callable[[], None] | None = None,
+    ) -> None:
+        super().__init__()
+        self._settings = settings
+        self._project_root = project_root
+        self._on_save = on_save
+
+        try:
+            from synapse.integrations.mcp_client import get_active_mcp_pool, load_mcp_server_configs
+
+            self._servers = load_mcp_server_configs(
+                path=getattr(settings, "mcp_config_path", None),
+                json_blob=getattr(settings, "mcp_servers_json", None),
+                workspace=getattr(settings, "workspace", None),
+            )
+        except Exception:  # noqa: BLE001
+            self._servers = []
+
+        pool = None
+        try:
+            pool = get_active_mcp_pool()
+        except Exception:  # noqa: BLE001
+            pass
+
+        # server_name → (all_discovered_tools, currently_included)
+        self._server_tools: dict[str, tuple[list[str], set[str]]] = {}
+        # server_name → collapsed flag
+        self._collapsed: dict[str, bool] = {}
+        for srv in self._servers:
+            discovered: list[str] = []
+            if pool is not None:
+                discovered = list(
+                    getattr(pool, "discovered_tools", {}).get(srv.name, [])
+                )
+            if srv.include_tools is not None:
+                included = set(srv.include_tools)
+            else:
+                included = set(discovered) if discovered else set()
+            self._server_tools[srv.name] = (discovered, included)
+
+    @property
+    def title_text(self) -> str:
+        return "MCP Tools"
+
+    def compose_body(self) -> ComposeResult:
+        items: list[OptionItem] = self._build_item_list()
+        self._items = items
+        # Options are mounted in on_mount via set_options.
+        yield from ()
+
+    def _build_item_list(self) -> list[OptionItem]:
+        items: list[OptionItem] = []
+        if not self._servers:
+            items.append(
+                OptionItem(
+                    key="none",
+                    label="(no servers configured)",
+                    checkable=False,
+                    show_bullet=False,
+                )
+            )
+            return items
+
+        for srv in self._servers:
+            discovered, included = self._server_tools.get(srv.name, ([], set()))
+            collapsed = self._collapsed.get(srv.name, False)
+            arrow = "\u25b6" if collapsed else "\u25bc"  # ▶ / ▼
+            status = "enabled" if srv.enabled else "disabled"
+            if srv.enabled and discovered:
+                n_sel = len(included)
+                n_tot = len(discovered)
+                sel_info = f"{n_sel}/{n_tot} selected" if n_sel < n_tot else "all selected"
+                meta = f"{sel_info} \u00b7 {srv.transport} \u00b7 {status}"
+            else:
+                meta = f"{srv.transport} \u00b7 {status}"
+            items.append(
+                OptionItem(
+                    key=f"__srv__{srv.name}",
+                    label=f"{arrow} Server: {srv.name}",
+                    meta=meta,
+                    checkable=False,
+                    show_bullet=False,
+                )
+            )
+            if not srv.enabled:
+                continue
+            if not discovered:
+                items.append(
+                    OptionItem(
+                        key=f"__hint__{srv.name}",
+                        label="(no tools \u2014 press 'r' to connect)",
+                        checkable=False,
+                        show_bullet=False,
+                        indent="    ",
+                    )
+                )
+                continue
+            if collapsed:
+                continue  # skip tool rows when collapsed
+            for tool_name in discovered:
+                checked = tool_name in included
+                items.append(
+                    OptionItem(
+                        key=f"__tool__{srv.name}__{tool_name}",
+                        label=tool_name,
+                        checkable=True,
+                        checked=checked,
+                        indent="    ",
+                    )
+                )
+        return items
+
+    def on_mount(self) -> None:
+        super().on_mount()
+        body = self.query_one("#dialog-body")
+        body.set_options(self._items, mark="", checkable=True)
+
+    def action_reload(self) -> None:
+        self.dismiss(("mcp-reload",))
+
+    def action_toggle_server(self) -> None:
+        """Temporarily toggle the selected MCP server and reload."""
+        body = self.query_one("#dialog-body")
+        key = body.selected_key
+        if key is None or not key.startswith("__srv__"):
+            return
+        server_name = key.split("__", 3)[2]
+        if not any(srv.name == server_name for srv in self._servers):
+            return
+        self.dismiss(("mcp-toggle-server", server_name))
+
+    def action_save(self) -> None:
+        """Collect tool selections and dismiss — save + reload runs off the UI thread."""
+        # Build per-server include_tools to write to config.
+        to_save: dict[str, list[str] | None] = {}
+        for srv in self._servers:
+            if not srv.enabled:
+                continue
+            discovered, included = self._server_tools.get(srv.name, ([], set()))
+            if not discovered:
+                continue
+            if included == set(discovered):
+                # All selected → remove include_tools (loads all)
+                to_save[srv.name] = None
+            else:
+                to_save[srv.name] = sorted(included)
+
+        if not to_save:
+            self.dismiss(("mcp-reload",))
+            return
+
+        self.dismiss(("mcp-save", to_save))
+
+    def _toggle_fold(self, server_name: str) -> None:
+        """Toggle collapse state for a server group."""
+        self._collapsed[server_name] = not self._collapsed.get(server_name, False)
+        self._rebuild()
+
+    def _toggle_current_tool(self) -> None:
+        """Toggle the tool at the current cursor position."""
+        body = self.query_one("#dialog-body")
+        key = body.selected_key
+        if key is None or not key.startswith("__tool__"):
+            return
+        parts = key.split("__", 3)
+        if len(parts) < 4:
+            return
+        server_name = parts[2]
+        tool_name = parts[3]
+        discovered, included = self._server_tools.get(server_name, ([], set()))
+        if tool_name not in discovered:
+            return
+        if tool_name in included:
+            included.discard(tool_name)
+        else:
+            included.add(tool_name)
+        self._server_tools[server_name] = (discovered, included)
+        self._rebuild()
+
+    def _on_selected(self, key: str | None) -> None:
+        if key is None:
+            self.dismiss(None)
+            return
+        if key.startswith("__tool__"):
+            self._toggle_current_tool()
+        elif key.startswith("__srv__"):
+            server_name = key.split("__", 3)[2]
+            self._toggle_fold(server_name)
+
+    def action_toggle_check(self) -> None:
+        body = self.query_one("#dialog-body")
+        key = body.selected_key
+        if key and key.startswith("__srv__"):
+            server_name = key.split("__", 3)[2]
+            self._toggle_fold(server_name)
+        else:
+            self._toggle_current_tool()
+
+    def action_select_all(self) -> None:
+        """Toggle: select all tools across all servers, or deselect all."""
+        all_selected = True
+        for srv in self._servers:
+            if not srv.enabled:
+                continue
+            discovered, included = self._server_tools.get(srv.name, ([], set()))
+            if discovered and included != set(discovered):
+                all_selected = False
+                break
+        target = not all_selected
+        for srv in self._servers:
+            if not srv.enabled:
+                continue
+            discovered, _ = self._server_tools.get(srv.name, ([], set()))
+            if discovered:
+                self._server_tools[srv.name] = (
+                    discovered,
+                    set(discovered) if target else set(),
+                )
+        self._rebuild()
+
+    def _rebuild(self) -> None:
+        body = self.query_one("#dialog-body")
+        old_idx = body._selected_idx
+        items = self._build_item_list()
+        self._items = items
+        body.set_options(items, mark="", checkable=True)
+        body._selected_idx = min(old_idx, len(items) - 1) if items else 0
+        body._sync_hover()

synapse/ui/dialogs/model_picker.py

@@ -0,0 +1,128 @@
+"""Model + thinking picker dialog — invoked by /model."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from textual.app import ComposeResult
+
+from synapse.models.registry import registry_from_settings, settings_thinking_label
+from synapse.ui.dialogs.base import (
+    DialogBase,
+    OptionItem,
+)
+
+THINKING_LEVELS = ("off", "minimal", "low", "medium", "high", "max")
+
+
+class ModelPickerDialog(DialogBase):
+    """Pick a model profile + thinking level.
+
+    dismiss result:
+      ("model", alias)       → switch model, use default thinking
+      ("thinking", level)    → change thinking only
+    """
+
+    _title_icon = "◆"
+
+    def __init__(self, settings: Any) -> None:
+        super().__init__()
+        self._settings = settings
+        try:
+            reg = registry_from_settings(settings)
+            current_model = getattr(settings, "active_model", None) or getattr(
+                reg, "default", None
+            )
+            current_think = settings_thinking_label(settings) or getattr(
+                settings, "reasoning_effort", "high"
+            )
+            model_names = list(reg.list_names())
+            allowed_think = list(reg.allowed_thinking_levels(current_model or ""))
+            if not allowed_think:
+                allowed_think = list(THINKING_LEVELS)
+        except Exception:  # noqa: BLE001
+            reg = None
+            current_model = None
+            current_think = "high"
+            model_names = []
+            allowed_think = list(THINKING_LEVELS)
+
+        self._reg = reg
+        self._current_model = current_model
+        self._current_think = current_think
+        self._model_names = model_names
+        self._allowed_think = allowed_think
+        self._model_count = len(model_names)
+
+    @property
+    def title_text(self) -> str:
+        return "Select Model"
+
+    def compose_body(self) -> ComposeResult:
+        # Population happens in on_mount after body is queryable.
+        return
+        yield  # pragma: no cover
+
+    def on_mount(self) -> None:
+        super().on_mount()
+        body = self.query_one("#dialog-body")
+        reg = self._reg
+        current = self._current_model
+        items: list[OptionItem] = []
+        # --- Model section ---
+        for name in self._model_names:
+            detail = ""
+            if reg is not None:
+                try:
+                    p = reg.get(name)
+                    detail = str(p.model or "")
+                except Exception:  # noqa: BLE001
+                    pass
+            # Keep one line: alias as label, provider model as trailing meta.
+            items.append(
+                OptionItem(
+                    key=name,
+                    label=name,
+                    meta=detail,
+                    selected=(name == current),
+                )
+            )
+        self._model_count = len(items)
+
+        # --- Thinking section ---
+        current_think = self._current_think or "high"
+        for level in self._allowed_think:
+            items.append(
+                OptionItem(
+                    key=f"thinking:{level}",
+                    label=level,
+                    selected=(level == current_think),
+                )
+            )
+        body.set_options(items[: self._model_count], mark="  ")
+
+        # Mount thinking section header + items manually.
+        think_items = items[self._model_count :]
+        if think_items:
+            body.append_section("Thinking")
+            body.append_options(think_items, mark="  ")
+
+    def _on_apply(self) -> None:
+        body = self.query_one("#dialog-body")
+        key = body.selected_key
+        if not key:
+            self.dismiss(None)
+            return
+        self._dismiss_with(key)
+
+    def _on_selected(self, key: str | None) -> None:
+        if key:
+            self._dismiss_with(key)
+        else:
+            self.dismiss(None)
+
+    def _dismiss_with(self, key: str) -> None:
+        if key.startswith("thinking:"):
+            self.dismiss(("thinking", key.split(":", 1)[1]))
+        else:
+            self.dismiss(("model", key))

synapse/ui/dialogs/safety_panel.py

@@ -0,0 +1,63 @@
+"""Safety profile picker — invoked by /safety."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from textual.app import ComposeResult
+
+from synapse.ui.dialogs.base import DialogBase, OptionItem, SectionHeader
+
+PROFILES = {
+    "dev-autopass": "All tool calls pass automatically",
+    "dev-approve": "Each tool call requires confirmation",
+    "readonly": "Read-only mode, all writes blocked",
+}
+
+
+class SafetyPanelDialog(DialogBase):
+    """Pick a safety profile."""
+
+    _title_icon = "◇"
+
+    def __init__(self, settings: Any) -> None:
+        super().__init__()
+        self._settings = settings
+        self._current = getattr(settings, "safety_profile", "dev-autopass")
+
+    @property
+    def title_text(self) -> str:
+        return "Safety Profile"
+
+    def compose_body(self) -> ComposeResult:
+        yield SectionHeader("Profile")
+        items: list[OptionItem] = []
+        for key, desc in PROFILES.items():
+            items.append(
+                OptionItem(
+                    key=key,
+                    label=key,
+                    detail=desc,
+                    selected=(key == self._current),
+                )
+            )
+        self._items = items
+
+    def on_mount(self) -> None:
+        super().on_mount()
+        body = self.query_one("#dialog-body")
+        body.set_options(self._items, mark="  ")
+
+    def _on_apply(self) -> None:
+        body = self.query_one("#dialog-body")
+        key = body.selected_key
+        if key:
+            self.dismiss(("safety", key))
+        else:
+            self.dismiss(None)
+
+    def _on_selected(self, key: str | None) -> None:
+        if key:
+            self._on_apply()
+        else:
+            self.dismiss(None)

synapse/ui/dialogs/session_list.py

@@ -0,0 +1,98 @@
+"""Session list dialog — invoked by F4, /switch, /session delete."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from textual.app import ComposeResult
+
+from synapse.ui.dialogs.base import DialogBase, OptionItem, SectionHeader
+
+
+class SessionListDialog(DialogBase):
+    """List sessions for switching, single deletion, or multi-select deletion.
+
+    dismiss result:
+      ("switch", [thread_id])   → TUI should call /switch
+      ("delete", [thread_id])   → TUI should call /session delete (single)
+      ("multi_delete", [...] )  → TUI should batch delete
+    """
+
+    _title_icon = "\u2261"  # ≡
+
+    def __init__(
+        self, settings: Any, *, current_thread: str, mode: str = "switch"
+    ) -> None:
+        super().__init__()
+        self._settings = settings
+        self._current_thread = current_thread
+        self._mode = mode  # "switch" | "delete" | "multi_delete"
+        self._checkable = mode == "multi_delete"
+        if self._checkable:
+            self._title_keys = (
+                "\u2191\u2193 space toggle \u00b7 ctrl+a all \u00b7 "
+                "enter delete \u00b7 esc"
+            )
+        elif mode == "delete":
+            self._title_keys = "\u2191\u2193 enter delete \u00b7 esc"
+        try:
+            from synapse.sessions.store import SessionStore
+
+            store = SessionStore(settings.resolved_sessions_path())
+            self._sessions = store.list_nonempty(limit=50)
+        except Exception:  # noqa: BLE001
+            self._sessions = []
+
+    @property
+    def title_text(self) -> str:
+        if self._checkable:
+            return "Delete Sessions (multi-select)"
+        return "Sessions" if self._mode == "switch" else "Delete Session"
+
+    def compose_body(self) -> ComposeResult:
+        if self._checkable:
+            yield SectionHeader(
+                "Select sessions to delete  \u00b7  "
+                "Space=toggle  Ctrl+A=all  Enter=confirm"
+            )
+        elif self._mode == "switch":
+            yield SectionHeader("Select a session")
+        else:
+            yield SectionHeader("Select a session to delete")
+        items: list[OptionItem] = []
+        for s in self._sessions:
+            title = (s.title or "").strip() or s.thread_id[:8]
+            detail = f"{s.updated_at[:16] or '?'}"
+            items.append(
+                OptionItem(
+                    key=s.thread_id,
+                    label=title,
+                    detail=detail,
+                    selected=(s.thread_id == self._current_thread),
+                )
+            )
+        self._items = items
+
+    def on_mount(self) -> None:
+        super().on_mount()
+        body = self.query_one("#dialog-body")
+        body.set_options(self._items, mark="  ", checkable=self._checkable)
+
+    def _on_apply(self) -> None:
+        body = self.query_one("#dialog-body")
+        if self._checkable:
+            keys = body.checked_keys
+            if not keys:
+                self.dismiss(None)
+                return
+            self.dismiss((self._mode, keys))
+        else:
+            key = body.selected_key
+            if not key:
+                self.dismiss(None)
+                return
+            self.dismiss((self._mode, [key]))
+
+    def _on_selected(self, key: str | None) -> None:
+        # In multi-select mode, Enter also confirms (apply).
+        self._on_apply()