ripperdoc 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

ripperdoc/cli/ui/models_tui/textual_app.py

@@ -0,0 +1,698 @@
+"""Textual app for managing model profiles."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional, Callable
+
+from rich import box
+from rich.panel import Panel
+from rich.table import Table
+
+from textual.app import App, ComposeResult
+from textual.containers import Container, Horizontal, VerticalScroll
+from textual.screen import ModalScreen
+from textual.widgets import (
+    Button,
+    Checkbox,
+    DataTable,
+    Footer,
+    Header,
+    Input,
+    Select,
+    Static,
+)
+
+from ripperdoc.core.config import (
+    ModelProfile,
+    ProviderType,
+    add_model_profile,
+    delete_model_profile,
+    get_global_config,
+    model_supports_vision,
+    set_model_pointer,
+)
+from ripperdoc.cli.ui.helpers import get_profile_for_pointer
+
+
+@dataclass
+class ModelFormResult:
+    name: str
+    profile: ModelProfile
+    set_as_main: bool = False
+    set_as_quick: bool = False
+
+
+class ConfirmScreen(ModalScreen[bool]):
+    """Simple confirmation dialog."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__()
+        self._message = message
+
+    def compose(self) -> ComposeResult:
+        with Container(id="confirm_dialog"):
+            yield Static(self._message, id="confirm_message")
+            with Horizontal(id="confirm_buttons"):
+                yield Button("Yes", id="confirm_yes", variant="primary")
+                yield Button("No", id="confirm_no")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "confirm_yes":
+            self.dismiss(True)
+        else:
+            self.dismiss(False)
+
+
+class ModelFormScreen(ModalScreen[Optional[ModelFormResult]]):
+    """Modal form for adding/editing models."""
+
+    def __init__(
+        self,
+        mode: str,
+        *,
+        existing_name: Optional[str] = None,
+        existing_profile: Optional[ModelProfile] = None,
+        default_set_main: bool = False,
+        default_set_quick: bool = False,
+    ) -> None:
+        super().__init__()
+        self._mode = mode
+        self._existing_name = existing_name
+        self._existing_profile = existing_profile
+        self._default_set_main = default_set_main
+        self._default_set_quick = default_set_quick
+        self._error_text: Optional[str] = None
+
+    def compose(self) -> ComposeResult:
+        title = "Add model" if self._mode == "add" else "Edit model"
+        with Container(id="form_dialog"):
+            yield Static(title, id="form_title")
+            yield Static("", id="form_error")
+            with VerticalScroll(id="form_fields"):
+                if self._mode == "add":
+                    yield Static("Profile name", classes="field_label")
+                    yield Input(placeholder="Profile name", id="name_input")
+                else:
+                    name_display = self._existing_name or ""
+                    yield Static("Profile name", classes="field_label")
+                    yield Static(f"{name_display}", id="name_static", classes="field_value")
+
+                current_profile = get_profile_for_pointer("main")
+                provider_default = (
+                    self._existing_profile.provider.value
+                    if self._existing_profile
+                    else (
+                        current_profile.provider.value
+                        if current_profile
+                        else ProviderType.ANTHROPIC.value
+                    )
+                )
+                provider_options = [(p.value, p.value) for p in ProviderType]
+                yield Static("Provider", classes="field_label")
+                yield Select(provider_options, value=provider_default, id="provider_select")
+
+                model_default = (
+                    self._existing_profile.model if self._existing_profile else ""
+                )
+                yield Static("Model name", classes="field_label")
+                yield Input(value=model_default, placeholder="Model name", id="model_input")
+
+                api_key_placeholder = "[set]" if (self._existing_profile and self._existing_profile.api_key) else "[not set]"
+                yield Static("API key", classes="field_label")
+                yield Input(
+                    placeholder=f"API key {api_key_placeholder} (blank=keep, '-'=clear)",
+                    password=True,
+                    id="api_key_input",
+                )
+
+                auth_placeholder = "[set]" if (self._existing_profile and self._existing_profile.auth_token) else "[not set]"
+                yield Static("Auth token (Anthropic only)", classes="field_label")
+                yield Input(
+                    placeholder=f"Auth token (Anthropic only) {auth_placeholder} (blank=keep, '-'=clear)",
+                    password=True,
+                    id="auth_token_input",
+                )
+
+                api_base_default = self._existing_profile.api_base if self._existing_profile else ""
+                yield Static("API base", classes="field_label")
+                yield Input(
+                    value=api_base_default or "",
+                    placeholder="API base (optional)",
+                    id="api_base_input",
+                )
+
+                max_tokens_default = self._existing_profile.max_tokens if self._existing_profile else 4096
+                yield Static("Max output tokens", classes="field_label")
+                yield Input(
+                    value=str(max_tokens_default),
+                    placeholder="Max output tokens",
+                    id="max_tokens_input",
+                )
+
+                temp_default = self._existing_profile.temperature if self._existing_profile else 0.7
+                yield Static("Temperature", classes="field_label")
+                yield Input(
+                    value=str(temp_default),
+                    placeholder="Temperature",
+                    id="temperature_input",
+                )
+
+                context_default = (
+                    str(self._existing_profile.context_window)
+                    if self._existing_profile and self._existing_profile.context_window
+                    else ""
+                )
+                yield Static("Context window tokens", classes="field_label")
+                yield Input(
+                    value=context_default,
+                    placeholder="Context window tokens (optional)",
+                    id="context_window_input",
+                )
+
+                yield Static("Supports vision", classes="field_label")
+                supports_default = (
+                    "auto"
+                    if not self._existing_profile or self._existing_profile.supports_vision is None
+                    else ("yes" if self._existing_profile.supports_vision else "no")
+                )
+                supports_options = [
+                    ("auto (detect)", "auto"),
+                    ("yes (image input)", "yes"),
+                    ("no (text-only)", "no"),
+                ]
+                yield Select(supports_options, value=supports_default, id="vision_select")
+
+                set_main_value = self._default_set_main
+                set_quick_value = self._default_set_quick
+                if self._mode == "edit" and self._existing_name:
+                    config = get_global_config()
+                    set_main_value = getattr(config.model_pointers, "main", "") == self._existing_name
+                    set_quick_value = (
+                        getattr(config.model_pointers, "quick", "") == self._existing_name
+                    )
+
+                yield Static("Set as main", classes="field_label")
+                yield Checkbox("Set as main", value=set_main_value, id="set_main")
+                yield Static("Set as quick", classes="field_label")
+                yield Checkbox("Set as quick", value=set_quick_value, id="set_quick")
+
+            with Horizontal(id="form_buttons"):
+                yield Button("Save", id="form_save", variant="primary")
+                yield Button("Cancel", id="form_cancel")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "form_cancel":
+            self.dismiss(None)
+            return
+        if event.button.id != "form_save":
+            return
+
+        name_input = self.query_one("#name_input", Input) if self._mode == "add" else None
+        provider_select = self.query_one("#provider_select", Select)
+        model_input = self.query_one("#model_input", Input)
+        api_key_input = self.query_one("#api_key_input", Input)
+        auth_token_input = self.query_one("#auth_token_input", Input)
+        api_base_input = self.query_one("#api_base_input", Input)
+        max_tokens_input = self.query_one("#max_tokens_input", Input)
+        temperature_input = self.query_one("#temperature_input", Input)
+        context_window_input = self.query_one("#context_window_input", Input)
+        vision_select = self.query_one("#vision_select", Select)
+
+        name = self._existing_name or ""
+        if self._mode == "add":
+            name = (name_input.value or "").strip() if name_input else ""
+            if not name:
+                self._set_error("Profile name is required.")
+                return
+
+        provider_value = (provider_select.value or "").strip()
+        try:
+            provider = ProviderType(provider_value)
+        except ValueError:
+            self._set_error("Invalid provider.")
+            return
+
+        model_name = (model_input.value or "").strip()
+        if not model_name:
+            self._set_error("Model name is required.")
+            return
+
+        api_key_raw = (api_key_input.value or "").strip()
+        if self._existing_profile:
+            if api_key_raw == "-":
+                api_key = None
+            elif api_key_raw:
+                api_key = api_key_raw
+            else:
+                api_key = self._existing_profile.api_key
+        else:
+            api_key = api_key_raw or None
+
+        auth_token_raw = (auth_token_input.value or "").strip()
+        if provider == ProviderType.ANTHROPIC or (
+            self._existing_profile and self._existing_profile.provider == ProviderType.ANTHROPIC
+        ):
+            if self._existing_profile:
+                if auth_token_raw == "-":
+                    auth_token = None
+                elif auth_token_raw:
+                    auth_token = auth_token_raw
+                else:
+                    auth_token = self._existing_profile.auth_token
+            else:
+                auth_token = auth_token_raw or None
+        else:
+            auth_token = None
+
+        api_base = (api_base_input.value or "").strip() or None
+
+        max_tokens = self._parse_int(max_tokens_input.value, "Max output tokens")
+        if max_tokens is None:
+            return
+
+        temperature = self._parse_float(temperature_input.value, "Temperature")
+        if temperature is None:
+            return
+
+        context_window = None
+        context_raw = (context_window_input.value or "").strip()
+        if context_raw:
+            context_window = self._parse_int(context_raw, "Context window tokens")
+            if context_window is None:
+                return
+
+        supports_value = (vision_select.value or "auto").strip().lower()
+        if supports_value == "yes":
+            supports_vision = True
+        elif supports_value == "no":
+            supports_vision = False
+        else:
+            supports_vision = None
+
+        set_as_main = bool(self.query_one("#set_main", Checkbox).value)
+        set_as_quick = bool(self.query_one("#set_quick", Checkbox).value)
+
+        profile = ModelProfile(
+            provider=provider,
+            model=model_name,
+            api_key=api_key,
+            auth_token=auth_token,
+            api_base=api_base,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            context_window=context_window,
+            supports_vision=supports_vision,
+        )
+
+        self.dismiss(
+            ModelFormResult(
+                name=name,
+                profile=profile,
+                set_as_main=set_as_main,
+                set_as_quick=set_as_quick,
+            )
+        )
+
+    def _set_error(self, message: str) -> None:
+        error_widget = self.query_one("#form_error", Static)
+        error_widget.update(message)
+
+    def _parse_int(self, raw: str, label: str) -> Optional[int]:
+        raw = (raw or "").strip()
+        if not raw:
+            if self._existing_profile and label == "Max output tokens":
+                return self._existing_profile.max_tokens
+            if self._existing_profile and label == "Context window tokens":
+                return self._existing_profile.context_window
+            if label == "Max output tokens":
+                return 4096
+            return None
+        try:
+            return int(raw)
+        except ValueError:
+            self._set_error(f"Invalid number for {label}.")
+            return None
+
+    def _parse_float(self, raw: str, label: str) -> Optional[float]:
+        raw = (raw or "").strip()
+        if not raw:
+            if self._existing_profile and label == "Temperature":
+                return self._existing_profile.temperature
+            if label == "Temperature":
+                return 0.7
+            return None
+        try:
+            return float(raw)
+        except ValueError:
+            self._set_error(f"Invalid number for {label}.")
+            return None
+
+
+class ModelsApp(App[None]):
+    CSS = """
+    #status_bar {
+        height: 1;
+        color: $text-muted;
+        padding: 0 1;
+    }
+
+    #body {
+        layout: horizontal;
+        height: 1fr;
+    }
+
+    #models_table {
+        width: 42%;
+        min-width: 40;
+    }
+
+    #details_panel {
+        width: 58%;
+        padding: 0 1;
+    }
+
+    #form_dialog, #confirm_dialog {
+        width: 72;
+        max-height: 90%;
+        background: $panel;
+        border: round $accent;
+        padding: 1 2;
+    }
+
+    #form_title {
+        text-style: bold;
+        padding: 0 0 1 0;
+    }
+
+    #form_error {
+        color: $error;
+        padding: 0 0 1 0;
+    }
+
+    #form_fields Input, #form_fields Select {
+        margin: 0 0 1 0;
+    }
+
+    #form_fields {
+        height: 1fr;
+        overflow: auto;
+    }
+
+    .field_label {
+        color: $text-muted;
+        padding: 0 0 0 0;
+    }
+
+    .field_value {
+        color: $accent;
+        text-style: bold;
+        padding: 0 0 1 0;
+    }
+
+
+    #form_buttons, #confirm_buttons {
+        align-horizontal: right;
+        padding-top: 1;
+        height: auto;
+    }
+
+    #confirm_message {
+        padding: 0 0 1 0;
+    }
+    """
+
+    BINDINGS = [
+        ("a", "add", "Add"),
+        ("e", "edit", "Edit"),
+        ("d", "delete", "Delete"),
+        ("m", "set_main", "Set main"),
+        ("k", "set_quick", "Set quick"),
+        ("r", "refresh", "Refresh"),
+        ("q", "quit", "Quit"),
+    ]
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._selected_name: Optional[str] = None
+        self._row_names: list[str] = []
+
+    def compose(self) -> ComposeResult:
+        yield Header(show_clock=False)
+        yield Static("", id="status_bar")
+        with Container(id="body"):
+            yield DataTable(id="models_table")
+            yield Static(id="details_panel")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        table = self.query_one("#models_table", DataTable)
+        table.add_columns("#", "Name", "Ptr", "Provider", "Model")
+        try:
+            table.cursor_type = "row"
+            table.zebra_stripes = True
+        except Exception:
+            pass
+        self._refresh_models(select_first=True)
+
+    def action_refresh(self) -> None:
+        self._refresh_models(select_first=False)
+        self._set_status("Refreshed.")
+
+    def action_add(self) -> None:
+        config = get_global_config()
+        default_set_main = (
+            not config.model_profiles
+            or getattr(config.model_pointers, "main", "") not in config.model_profiles
+        )
+        screen = ModelFormScreen(
+            "add",
+            default_set_main=default_set_main,
+            default_set_quick=False,
+        )
+        self.push_screen(screen, self._handle_add_result)
+
+    def action_edit(self) -> None:
+        profile = self._selected_profile()
+        if not profile:
+            self._set_status("No model selected.")
+            return
+        screen = ModelFormScreen(
+            "edit",
+            existing_name=self._selected_name,
+            existing_profile=profile,
+        )
+        self.push_screen(screen, self._handle_edit_result)
+
+    def action_delete(self) -> None:
+        profile = self._selected_profile()
+        if not profile:
+            self._set_status("No model selected.")
+            return
+        screen = ConfirmScreen(f"Delete model '{self._selected_name}'?")
+        self.push_screen(screen, self._handle_delete_confirm)
+
+    def action_set_main(self) -> None:
+        if not self._selected_name:
+            self._set_status("No model selected.")
+            return
+        try:
+            set_model_pointer("main", self._selected_name)
+            self._set_status(f"Main -> {self._selected_name}")
+            self._refresh_models(select_first=False)
+        except (ValueError, KeyError, OSError, IOError, PermissionError) as exc:
+            self._set_status(str(exc))
+
+    def action_set_quick(self) -> None:
+        if not self._selected_name:
+            self._set_status("No model selected.")
+            return
+        try:
+            set_model_pointer("quick", self._selected_name)
+            self._set_status(f"Quick -> {self._selected_name}")
+            self._refresh_models(select_first=False)
+        except (ValueError, KeyError, OSError, IOError, PermissionError) as exc:
+            self._set_status(str(exc))
+
+    def on_data_table_row_highlighted(self, event: DataTable.RowHighlighted) -> None:
+        self._select_by_index(int(event.cursor_row))
+
+    def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:
+        self._select_by_index(int(event.cursor_row))
+        self.action_edit()
+
+    def _handle_add_result(self, result: Optional[ModelFormResult]) -> None:
+        if not result:
+            return
+        try:
+            add_model_profile(
+                result.name,
+                result.profile,
+                overwrite=False,
+                set_as_main=result.set_as_main,
+            )
+            if result.set_as_quick:
+                set_model_pointer("quick", result.name)
+        except (OSError, IOError, ValueError, TypeError, PermissionError) as exc:
+            self._set_status(str(exc))
+            return
+        self._selected_name = result.name
+        self._set_status(f"Saved {result.name}.")
+        self._refresh_models(select_first=False)
+
+    def _handle_edit_result(self, result: Optional[ModelFormResult]) -> None:
+        if not result:
+            return
+        try:
+            add_model_profile(
+                result.name,
+                result.profile,
+                overwrite=True,
+                set_as_main=False,
+            )
+            if result.set_as_main:
+                set_model_pointer("main", result.name)
+            if result.set_as_quick:
+                set_model_pointer("quick", result.name)
+        except (OSError, IOError, ValueError, TypeError, PermissionError) as exc:
+            self._set_status(str(exc))
+            return
+        self._selected_name = result.name
+        self._set_status(f"Updated {result.name}.")
+        self._refresh_models(select_first=False)
+
+    def _handle_delete_confirm(self, confirmed: bool) -> None:
+        if not confirmed or not self._selected_name:
+            return
+        try:
+            delete_model_profile(self._selected_name)
+        except (OSError, IOError, KeyError, PermissionError) as exc:
+            self._set_status(str(exc))
+            return
+        self._set_status(f"Deleted {self._selected_name}.")
+        self._selected_name = None
+        self._refresh_models(select_first=True)
+
+    def _refresh_models(self, select_first: bool) -> None:
+        config = get_global_config()
+        table = self.query_one("#models_table", DataTable)
+        table.clear(columns=False)
+        pointer_map = config.model_pointers.model_dump()
+        self._row_names = []
+
+        for idx, (name, profile) in enumerate(config.model_profiles.items(), start=1):
+            self._row_names.append(name)
+            markers = [ptr for ptr, value in pointer_map.items() if value == name]
+            pointer_label = ",".join(markers) if markers else "-"
+            table.add_row(
+                str(idx),
+                name,
+                pointer_label,
+                profile.provider.value,
+                profile.model,
+            )
+
+        if not config.model_profiles:
+            self._selected_name = None
+            self._update_details()
+            return
+
+        if self._selected_name and self._selected_name in config.model_profiles:
+            try:
+                row_index = self._row_names.index(self._selected_name)
+            except ValueError:
+                row_index = 0
+            self._move_cursor(table, row_index)
+            self._update_details()
+            return
+
+        if select_first:
+            first_name = next(iter(config.model_profiles))
+            self._selected_name = first_name
+            self._move_cursor(table, 0)
+            self._update_details()
+
+    def _select_by_index(self, row_index: int) -> None:
+        if row_index < 0 or row_index >= len(self._row_names):
+            return
+        self._selected_name = self._row_names[row_index]
+        self._update_details()
+
+    def _move_cursor(self, table: DataTable, row_index: int) -> None:
+        try:
+            table.move_cursor(row=row_index)
+        except TypeError:
+            try:
+                table.move_cursor(row_index, 0)
+            except Exception:
+                pass
+        except Exception:
+            pass
+
+    def _selected_profile(self) -> Optional[ModelProfile]:
+        if not self._selected_name:
+            return None
+        config = get_global_config()
+        return config.model_profiles.get(self._selected_name)
+
+    def _update_details(self) -> None:
+        details = self.query_one("#details_panel", Static)
+        if not self._selected_name:
+            details.update("No model selected.")
+            return
+        config = get_global_config()
+        profile = config.model_profiles.get(self._selected_name)
+        if not profile:
+            details.update("No model selected.")
+            return
+        pointer_map = config.model_pointers.model_dump()
+        markers = [ptr for ptr, value in pointer_map.items() if value == self._selected_name]
+        marker_text = ", ".join(markers) if markers else "-"
+        vision_display = self._vision_display(profile)
+
+        table = Table.grid(padding=(0, 2))
+        table.add_column(style="cyan", no_wrap=True)
+        table.add_column()
+        table.add_row("Profile", self._selected_name)
+        table.add_row("Pointers", marker_text)
+        table.add_row("Provider", profile.provider.value)
+        table.add_row("Model", profile.model)
+        table.add_row("API base", profile.api_base or "-")
+        table.add_row(
+            "Context",
+            str(profile.context_window) if profile.context_window else "auto",
+        )
+        table.add_row("Max tokens", str(profile.max_tokens))
+        table.add_row("Temperature", str(profile.temperature))
+        table.add_row("Vision", vision_display)
+        table.add_row("API key", "set" if profile.api_key else "unset")
+        if profile.provider == ProviderType.ANTHROPIC:
+            table.add_row(
+                "Auth token",
+                "set" if getattr(profile, "auth_token", None) else "unset",
+            )
+        if profile.openai_tool_mode:
+            table.add_row("OpenAI tool mode", profile.openai_tool_mode)
+        if profile.thinking_mode:
+            table.add_row("Thinking mode", profile.thinking_mode)
+
+        details.update(Panel(table, title=f"Model: {self._selected_name}", box=box.ROUNDED))
+
+    def _vision_display(self, profile: ModelProfile) -> str:
+        if profile.supports_vision is None:
+            detected = model_supports_vision(profile)
+            return f"auto (detected {'yes' if detected else 'no'})"
+        return "yes" if profile.supports_vision else "no"
+
+    def _set_status(self, message: str) -> None:
+        status = self.query_one("#status_bar", Static)
+        status.update(message)
+
+
+def run_models_tui(on_exit: Optional[Callable[[], Any]] = None) -> bool:
+    """Run the Textual models TUI."""
+    app = ModelsApp()
+    app.run()
+    if on_exit:
+        on_exit()
+    return True