vtx-coding-agent 0.1.1__py3-none-any.whl

vtx/ui/commands/__init__.py

@@ -0,0 +1,100 @@
+"""Slash-command handling for the Vtx app, split by domain:
+
+- settings.py - /settings, /themes, /permissions, /thinking, /notifications
+- models.py   - /model
+- sessions.py - /clear, /new, /resume, /tree, /session, /handoff, /compact, /export, /copy
+- auth.py     - /login, /logout
+
+CommandsMixin composes the domain mixins and owns the command router.
+"""
+
+from __future__ import annotations
+
+from ..chat import ChatLog
+from .auth import AuthCommands
+from .base import CommandSupport
+from .models import ModelCommands
+from .sessions import SessionCommands
+from .settings import SettingsCommands, SettingsSelectionResult
+
+
+class CommandsMixin(SettingsCommands, ModelCommands, SessionCommands, AuthCommands):
+    def _handle_command(self, text: str) -> bool:
+        parts = text[1:].split(maxsplit=1)
+        cmd = parts[0] if parts else ""
+        args = parts[1] if len(parts) > 1 else ""
+
+        if cmd in ("quit", "exit", "q"):
+            self.exit()
+            return True
+        if cmd == "help":
+            self._show_help()
+            return True
+        if cmd == "clear":
+            self._clear_conversation()
+            return True
+        if cmd == "model":
+            self._handle_model_command(args)
+            return True
+        if cmd == "new":
+            self._new_conversation()
+            return True
+        if cmd == "settings":
+            self._handle_settings_command()
+            return True
+        if cmd == "themes":
+            self._handle_themes_command(args)
+            return True
+        if cmd == "permissions":
+            self._handle_permissions_command(args)
+            return True
+        if cmd == "thinking":
+            self._handle_thinking_command(args)
+            return True
+        if cmd == "notifications":
+            self._handle_notifications_command(args)
+            return True
+        if cmd == "handoff":
+            self._handle_handoff_command(args)
+            return True
+        if cmd == "resume":
+            self._show_resume_sessions()
+            return True
+        if cmd == "tree":
+            self._show_tree_selector()
+            return True
+        if cmd == "session":
+            self._show_session_info()
+            return True
+        if cmd == "login":
+            self._handle_login_command(args)
+            return True
+        if cmd == "logout":
+            self._handle_logout_command(args)
+            return True
+        if cmd == "export":
+            self._handle_export_command()
+            return True
+        if cmd == "copy":
+            self._handle_copy_command()
+            return True
+        if cmd == "compact":
+            self._handle_compact_command()
+            return True
+
+        return False
+
+    def _show_help(self) -> None:
+        chat = self.query_one("#chat-log", ChatLog)
+        chat.add_help_details()
+
+
+__all__ = [
+    "AuthCommands",
+    "CommandSupport",
+    "CommandsMixin",
+    "ModelCommands",
+    "SessionCommands",
+    "SettingsCommands",
+    "SettingsSelectionResult",
+]

vtx/ui/commands/auth.py

@@ -0,0 +1,306 @@
+"""/login and /logout commands - provider authentication flows.
+
+There are two kinds of "logins" in vtx:
+
+- **OAuth flows** for GitHub Copilot and OpenAI Codex, where the user is sent
+  to a browser to authorize and we store long-lived tokens.
+- **API-key entries** for every provider in ``src/vtx/llm/provider.yaml``.
+  These don't need OAuth; the user pastes an API key and we store it in
+  ``~/.vtx/dynamic_auth.json`` (mode 0600).
+
+Both kinds show up together in the ``/login`` picker so the user has a single
+place to manage credentials. Adding a new provider to ``provider.yaml``
+automatically makes it appear in the picker.
+"""
+
+from __future__ import annotations
+
+from ...llm import (
+    clear_api_key,
+    clear_copilot_credentials,
+    clear_openai_credentials,
+    copilot_login,
+    get_copilot_token,
+    get_dynamic_api_key,
+    get_provider_info,
+    get_provider_status,
+    get_valid_openai_credentials,
+    list_providers,
+    openai_login,
+    save_api_key,
+)
+from ...llm import is_copilot_logged_in as has_saved_copilot_credentials
+from ...llm import is_openai_logged_in as has_saved_openai_credentials
+from ..chat import ChatLog
+from ..floating_list import ListItem
+from ..input import InputBox
+from ..selection_mode import SelectionMode
+from .base import CommandSupport
+
+
+def _status_label(provider: str) -> str:
+    """Build the description shown next to a provider in the picker."""
+    status = get_provider_status(provider)
+    if status is None:
+        return ""
+    if status.has_env_key:
+        return f"{status.env_var or 'env'} set"
+    if status.has_stored_key:
+        return "key stored"
+    if status.api_key_optional:
+        return "no key needed"
+    return "key required"
+
+
+class AuthCommands(CommandSupport):
+    def _handle_login_command(self, args: str) -> None:
+        providers: list[tuple[str, str, bool, str]] = [
+            ("github-copilot", "GitHub Copilot", has_saved_copilot_credentials(), "oauth"),
+            ("openai", "OpenAI (ChatGPT/Codex)", has_saved_openai_credentials(), "oauth"),
+        ]
+
+        # Every provider in provider.yaml gets a key-based entry.
+        for p in list_providers():
+            providers.append((p.slug, p.display_name, False, "key"))
+
+        items: list[ListItem] = []
+        for provider_id, name, has_oauth, kind in providers:
+            if kind == "oauth":
+                description = "saved credentials" if has_oauth else "oauth login"
+            else:
+                description = _status_label(provider_id)
+            items.append(ListItem(value=provider_id, label=name, description=description))
+
+        self._show_selection_picker(items, SelectionMode.LOGIN)
+
+    def _select_login_provider(self, provider_id: str) -> None:
+        if provider_id == "github-copilot":
+            self.run_worker(self._copilot_login_flow(), exclusive=False)
+            return
+
+        if provider_id == "openai":
+            self.run_worker(self._openai_login_flow(), exclusive=False)
+            return
+
+        if get_provider_info(provider_id) is not None:
+            self._prompt_for_api_key(provider_id)
+            return
+
+    def _prompt_for_api_key(self, provider_id: str) -> None:
+        """Show a single-line input that captures the API key and stores it."""
+        status = get_provider_status(provider_id)
+        chat = self.query_one("#chat-log", ChatLog)
+
+        if status is None:
+            chat.add_info_message(f"Unknown provider: {provider_id}", error=True)
+            return
+
+        env_var = status.env_var
+        prompt_text = f"Enter API key for {provider_id}"
+        if env_var:
+            prompt_text += f" (or set {env_var})"
+        prompt_text += ":"
+
+        existing = get_dynamic_api_key(provider_id)
+        if existing:
+            # Already configured - allow update or clear.
+            self._show_api_key_actions(provider_id)
+            return
+
+        chat.add_info_message(f"Provider {provider_id} needs an API key. {prompt_text}")
+
+        input_box = self.query_one("#input-box", InputBox)
+        input_box.set_placeholder(f"Paste {provider_id} API key (or /cancel)")
+        self._selection_mode = SelectionMode.API_KEY
+        self._pending_api_key_provider = provider_id
+        input_box.focus()
+
+    def _show_api_key_actions(self, provider_id: str) -> None:
+        """For providers with a stored key, offer replace/clear."""
+        items = [
+            ListItem(value="update", label="Update key", description="paste a new API key"),
+            ListItem(value="clear", label="Clear key", description="remove stored credentials"),
+            ListItem(value="cancel", label="Cancel", description="keep current key"),
+        ]
+        self._pending_api_key_provider = provider_id
+        self._show_selection_picker(items, SelectionMode.API_KEY_ACTION)
+
+    def _select_api_key_action(self, action: str) -> None:
+        provider_id = getattr(self, "_pending_api_key_provider", None)
+        if not provider_id:
+            return
+        chat = self.query_one("#chat-log", ChatLog)
+
+        if action == "clear":
+            removed = clear_api_key(provider_id)
+            if removed:
+                chat.add_info_message(f"Cleared stored API key for {provider_id}")
+            else:
+                chat.add_info_message(f"No stored API key for {provider_id}")
+            self._pending_api_key_provider = None
+            return
+
+        if action == "cancel":
+            chat.add_info_message(f"Kept existing API key for {provider_id}")
+            self._pending_api_key_provider = None
+            return
+
+        if action == "update":
+            self._pending_api_key_provider = provider_id
+            input_box = self.query_one("#input-box", InputBox)
+            input_box.set_placeholder(f"Paste new {provider_id} API key (or /cancel)")
+            self._selection_mode = SelectionMode.API_KEY
+            input_box.focus()
+            return
+
+    def _submit_api_key(self, raw: str) -> None:
+        """Called by the input layer when the user submits a key in API_KEY mode."""
+        from ..input import InputBox
+
+        provider_id = getattr(self, "_pending_api_key_provider", None)
+        chat = self.query_one("#chat-log", ChatLog)
+        # Reset state immediately so a later error doesn't leave us stuck.
+        self._pending_api_key_provider = None
+        self._selection_mode = None
+
+        # Restore the input box to its normal state.
+        try:
+            input_box = self.query_one("#input-box", InputBox)
+            input_box.set_placeholder("")
+            input_box.set_autocomplete_enabled(True)
+            input_box.clear()
+        except Exception:
+            pass
+
+        key = raw.strip()
+        if not key or key.startswith("/"):
+            chat.add_info_message("API key entry cancelled")
+            return
+
+        if not provider_id:
+            chat.add_info_message("No provider selected for API key", error=True)
+            return
+
+        try:
+            save_api_key(provider_id, key)
+        except ValueError as exc:
+            chat.add_info_message(str(exc), error=True)
+            return
+
+        chat.add_info_message(
+            f"Saved API key for {provider_id} to ~/.vtx/dynamic_auth.json. "
+            f"Run `/model refresh {provider_id}` to fetch its model list, "
+            "then `/model` to pick one."
+        )
+
+    async def _copilot_login_flow(self) -> None:
+        import webbrowser
+
+        chat = self.query_one("#chat-log", ChatLog)
+        had_saved_credentials = has_saved_copilot_credentials()
+
+        def on_user_code(url: str, code: str) -> None:
+            webbrowser.open(url)
+            self.call_later(
+                chat.add_info_message,
+                f"Opening browser to: {url}\n"
+                f"Enter this code: {code}\n\n"
+                "Waiting for authorization...",
+            )
+
+        try:
+            if await get_copilot_token():
+                chat.add_info_message("Already logged in to GitHub Copilot")
+                return
+
+            if had_saved_credentials:
+                chat.add_info_message(
+                    "Your saved GitHub Copilot session is no longer valid.", warning=True
+                )
+            else:
+                chat.add_info_message("Starting GitHub Copilot login...")
+
+            await copilot_login(on_user_code=on_user_code)
+            chat.add_info_message(
+                "Successfully logged in to GitHub Copilot!\n"
+                "You can now use /model to select Copilot models."
+            )
+        except Exception as e:
+            chat.add_info_message(f"Login failed: {e}", error=True)
+
+    async def _openai_login_flow(self) -> None:
+        import webbrowser
+
+        chat = self.query_one("#chat-log", ChatLog)
+        had_saved_credentials = has_saved_openai_credentials()
+
+        def on_auth_url(url: str) -> None:
+            webbrowser.open(url)
+            self.call_later(
+                chat.add_info_message,
+                "Opening browser for OpenAI OAuth...\n"
+                f"If browser does not open, visit:\n{url}\n\n"
+                "Waiting for authorization callback on http://localhost:1455/auth/callback ...",
+            )
+
+        try:
+            if await get_valid_openai_credentials():
+                chat.add_info_message("Already logged in to OpenAI")
+                return
+
+            if had_saved_credentials:
+                chat.add_info_message(
+                    "Your saved OpenAI session is no longer valid.", warning=True
+                )
+            else:
+                chat.add_info_message("Starting OpenAI login...")
+
+            await openai_login(on_auth_url=on_auth_url)
+            chat.add_info_message(
+                "Successfully logged in to OpenAI!\n"
+                "You can now use /model to select openai-codex models."
+            )
+        except Exception as e:
+            chat.add_info_message(f"Login failed: {e}", error=True)
+
+    def _handle_logout_command(self, args: str) -> None:
+        items: list[ListItem] = []
+
+        if has_saved_copilot_credentials():
+            items.append(ListItem(value="github-copilot", label="GitHub Copilot", description=""))
+        if has_saved_openai_credentials():
+            items.append(ListItem(value="openai", label="OpenAI (ChatGPT/Codex)", description=""))
+
+        for p in list_providers():
+            status = get_provider_status(p.slug)
+            if status and status.has_stored_key:
+                items.append(
+                    ListItem(value=p.slug, label=p.display_name, description="key stored")
+                )
+
+        if not items:
+            chat = self.query_one("#chat-log", ChatLog)
+            chat.add_info_message("No providers logged in")
+            return
+
+        self._show_selection_picker(items, SelectionMode.LOGOUT)
+
+    def _select_logout_provider(self, provider_id: str) -> None:
+        chat = self.query_one("#chat-log", ChatLog)
+
+        if provider_id == "github-copilot":
+            clear_copilot_credentials()
+            chat.add_info_message("Logged out of GitHub Copilot")
+            return
+
+        if provider_id == "openai":
+            clear_openai_credentials()
+            chat.add_info_message("Logged out of OpenAI")
+            return
+
+        if get_provider_info(provider_id) is not None:
+            if clear_api_key(provider_id):
+                chat.add_info_message(f"Cleared stored API key for {provider_id}")
+            else:
+                chat.add_info_message(f"No stored API key for {provider_id}")
+            return

vtx/ui/commands/base.py

@@ -0,0 +1,122 @@
+"""Shared plumbing for the command mixins: expected app surface and picker helpers."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping, Sequence
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from ...runtime import ConversationRuntime
+from ...session import Session
+from ..chat import ChatLog
+from ..floating_list import ListItem
+from ..input import InputBox
+from ..selection_mode import SelectionMode
+
+Choice = TypeVar("Choice", bound=str)
+
+
+class CommandSupport:
+    """Attributes and helpers every command mixin can rely on."""
+
+    _cwd: str
+    _api_key: str | None
+    _agent: Any
+    _is_running: bool
+    _selection_mode: Any
+    _tools: list
+    _openai_compat_auth_mode: Any
+    _anthropic_compat_auth_mode: Any
+    _runtime: ConversationRuntime
+
+    # Methods from App - declared for type checking
+    if TYPE_CHECKING:
+        exit: Any
+        notify: Any
+        query_one: Any
+        run_worker: Any
+        call_later: Any
+        batch_update: Any
+        _settings_active: bool
+        _settings_selected_value: str | None
+
+    # Methods from other mixins/main class
+    if TYPE_CHECKING:
+
+        def _sync_runtime_state(self) -> None: ...
+        def _sync_slash_commands(self) -> None: ...
+        def _render_session_entries(self, session: Session) -> None: ...
+        def _apply_theme(self, theme_id: str) -> None: ...
+        def _apply_thinking_level_style(self, level: str) -> None: ...
+        def _show_completion_list(
+            self,
+            items: list[ListItem],
+            *,
+            searchable: bool = False,
+            max_label_width: int | None = None,
+        ) -> None: ...
+        def _hide_completion_list(self, *, restore_info_bar: bool = True) -> None: ...
+        def _is_chat_at_bottom(self) -> bool: ...
+        def _restore_chat_scroll_after_refresh(self, was_at_bottom: bool) -> None: ...
+
+    def _show_selection_picker(
+        self,
+        items: list[ListItem],
+        selection_mode: SelectionMode,
+        *,
+        searchable: bool = True,
+        max_label_width: int | None = None,
+    ) -> None:
+        input_box = self.query_one("#input-box", InputBox)
+        was_at_bottom = self._is_chat_at_bottom()
+
+        with self.batch_update():
+            self._show_completion_list(
+                items, searchable=searchable, max_label_width=max_label_width
+            )
+            input_box.clear()
+            input_box.set_autocomplete_enabled(False)
+            input_box.set_completing(True)
+            input_box.focus()
+
+        self._selection_mode = selection_mode
+        self._restore_chat_scroll_after_refresh(was_at_bottom)
+
+    def _build_choice_items(
+        self, choices: Sequence[Choice], current: Choice, descriptions: Mapping[Choice, str]
+    ) -> list[ListItem[Choice]]:
+        return [
+            ListItem(
+                value=choice,
+                label=f"{choice} ✓" if choice == current else choice,
+                description=descriptions[choice],
+            )
+            for choice in choices
+        ]
+
+    def _handle_choice_command(
+        self,
+        args: str,
+        *,
+        name: str,
+        choices: Sequence[Choice],
+        current: Choice,
+        descriptions: Mapping[Choice, str],
+        selection_mode: SelectionMode,
+        select: Callable[[Choice], None],
+    ) -> None:
+        chat = self.query_one("#chat-log", ChatLog)
+
+        requested = args.strip()
+        if requested:
+            if requested in choices:
+                select(cast(Choice, requested))
+            else:
+                valid = ", ".join(choices)
+                chat.add_info_message(
+                    f"Invalid {name} mode: {requested}. Use one of: {valid}", error=True
+                )
+            return
+
+        self._show_selection_picker(
+            self._build_choice_items(choices, current, descriptions), selection_mode
+        )

vtx/ui/commands/models.py

@@ -0,0 +1,144 @@
+"""/model command - listing and switching models."""
+
+from __future__ import annotations
+
+import asyncio
+
+from ...config import get_config
+from ...llm import (
+    DYNAMIC_PROVIDERS,
+    Model,
+    get_all_models,
+    get_dynamic_provider,
+    refresh_all_providers,
+    refresh_provider,
+)
+from ..chat import ChatLog
+from ..floating_list import ListItem
+from ..selection_mode import SelectionMode
+from ..widgets import InfoBar
+from .base import CommandSupport
+
+
+def _parse_hidden_entries(entries: list[str]) -> tuple[set[str], set[tuple[str, str]]]:
+    """Split hidden-model entries into provider names and (provider, model) combos."""
+    hidden_providers: set[str] = set()
+    hidden_combos: set[tuple[str, str]] = set()
+    for entry in entries:
+        if ":" in entry:
+            provider, _, model_id = entry.partition(":")
+            provider, model_id = provider.strip(), model_id.strip()
+            if provider and model_id:
+                hidden_combos.add((provider, model_id))
+        else:
+            entry = entry.strip()
+            if entry:
+                hidden_providers.add(entry)
+    return hidden_providers, hidden_combos
+
+
+def _is_model_hidden(
+    model: Model, hidden_providers: set[str], hidden_combos: set[tuple[str, str]]
+) -> bool:
+    return model.provider in hidden_providers or (model.provider, model.id) in hidden_combos
+
+
+class ModelCommands(CommandSupport):
+    def _handle_model_command(self, args: str) -> None:
+        stripped = args.strip()
+        if stripped:
+            if stripped == "refresh":
+                self.run_worker(self._refresh_dynamic_models(None), exclusive=False)
+                return
+            if stripped.startswith("refresh "):
+                provider = stripped[len("refresh ") :].strip()
+                self.run_worker(self._refresh_dynamic_models(provider or None), exclusive=False)
+                return
+            chat = self.query_one("#chat-log", ChatLog)
+            chat.add_info_message(
+                "Unknown /model sub-command. Use: /model, /model refresh, "
+                "/model refresh <provider>",
+                error=True,
+            )
+            return
+
+        hidden_providers, hidden_combos = _parse_hidden_entries(get_config().ui.hidden_models)
+        models = get_all_models()
+        # Filter out hidden models, but always keep the currently active model
+        # so its selection state is visible in the picker.
+        if hidden_providers or hidden_combos:
+            models = [
+                m
+                for m in models
+                if not _is_model_hidden(m, hidden_providers, hidden_combos)
+                or (m.id == self._runtime.model and m.provider == self._runtime.model_provider)
+            ]
+        if not models:
+            self.notify("No models configured", title="Models", timeout=3, severity="warning")
+            return
+
+        models.sort(key=lambda m: (m.provider, m.id))
+
+        items: list[ListItem] = []
+        for m in models:
+            parts = [m.provider]
+            if not m.supports_images:
+                parts.append("[no-vision]")
+            caption = " ".join(parts)
+            label = (
+                f"{m.id} ✓"
+                if m.id == self._runtime.model and m.provider == self._runtime.model_provider
+                else m.id
+            )
+            items.append(ListItem(value=m, label=label, description=caption))
+
+        self._show_selection_picker(items, SelectionMode.MODEL)
+
+    def _select_model(self, model) -> None:
+        chat = self.query_one("#chat-log", ChatLog)
+        info_bar = self.query_one("#info-bar", InfoBar)
+
+        try:
+            self._runtime.switch_model(model)
+        except ValueError as e:
+            chat.add_info_message(str(e), error=True)
+            return
+        self._sync_runtime_state()
+
+        info_bar.set_model(model.id, model.provider)
+
+        chat.add_info_message(f"Model changed to {model.id} ({model.provider})")
+
+    async def _refresh_dynamic_models(self, provider: str | None) -> None:
+        chat = self.query_one("#chat-log", ChatLog)
+
+        if provider is not None and get_dynamic_provider(provider) is None:
+            valid = ", ".join(sorted(DYNAMIC_PROVIDERS))
+            chat.add_info_message(
+                f"Unknown provider: {provider}. Dynamic providers: {valid}", error=True
+            )
+            return
+
+        chat.add_info_message(f"Refreshing {provider if provider else 'all dynamic providers'}...")
+
+        def _run() -> dict[str, int | str]:
+            if provider is not None:
+                try:
+                    count = refresh_provider(provider)
+                except Exception as exc:
+                    return {provider: -1, "_error": str(exc)}
+                return {provider: count}
+            return dict[str, int | str](refresh_all_providers())
+
+        try:
+            result = await asyncio.to_thread(_run)
+        except Exception as exc:
+            chat.add_info_message(f"Refresh failed: {exc}", error=True)
+            return
+
+        error = result.pop("_error", None)
+        if error:
+            chat.add_info_message(f"Refresh failed: {error}", error=True)
+            return
+        lines = [f"  {name}: {count} models" for name, count in result.items()]
+        chat.add_info_message("Refresh complete:\n" + "\n".join(lines))