tunacode-cli 0.1.21__py3-none-any.whl

tunacode/ui/screens/session_picker.py

@@ -0,0 +1,181 @@
+"""Session picker modal screen for TunaCode."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.screen import Screen
+from textual.widgets import OptionList, Static
+from textual.widgets.option_list import Option
+
+
+class SessionPickerScreen(Screen[str | None]):
+    """Modal screen for session selection with message preview."""
+
+    CSS = """
+    SessionPickerScreen {
+        align: center middle;
+    }
+
+    #session-container {
+        width: 70;
+        height: auto;
+        max-height: 24;
+        border: solid $primary;
+        background: $surface;
+        padding: 1 2;
+    }
+
+    #session-title {
+        text-style: bold;
+        color: $accent;
+        text-align: center;
+        margin-bottom: 1;
+    }
+
+    #session-list {
+        height: auto;
+        max-height: 12;
+    }
+
+    #session-preview {
+        height: 6;
+        margin-top: 1;
+        border-top: solid $primary;
+        padding-top: 1;
+        color: $text-muted;
+    }
+    """
+
+    BINDINGS = [
+        ("escape", "cancel", "Cancel"),
+    ]
+
+    def __init__(
+        self,
+        sessions: list[dict[str, Any]],
+        current_session_id: str,
+    ) -> None:
+        super().__init__()
+        self._sessions = sessions
+        self._current_session_id = current_session_id
+        self._session_map: dict[str, dict[str, Any]] = {s["session_id"]: s for s in sessions}
+
+    def compose(self) -> ComposeResult:
+        options: list[Option] = []
+        highlight_index = 0
+
+        for i, session in enumerate(self._sessions):
+            session_id = session["session_id"]
+            short_id = session_id[:8]
+            msg_count = session.get("message_count", 0)
+            model = session.get("current_model", "unknown")
+            if "/" in model:
+                model = model.split("/")[-1]
+            last_mod = session.get("last_modified", "")[:10]
+
+            is_current = session_id == self._current_session_id
+            current_marker = " (current)" if is_current else ""
+
+            label = f"{short_id}{current_marker} | {msg_count} msgs | {model} | {last_mod}"
+            options.append(Option(label, id=session_id))
+
+            if is_current:
+                highlight_index = i
+
+        with Vertical(id="session-container"):
+            yield Static("Resume Session", id="session-title")
+            option_list = OptionList(*options, id="session-list")
+            if options:
+                option_list.highlighted = highlight_index
+            yield option_list
+            yield Static("Select a session to preview", id="session-preview")
+
+    def on_option_list_option_highlighted(self, event: OptionList.OptionHighlighted) -> None:
+        """Show preview of messages when highlighting a session."""
+        preview_widget = self.query_one("#session-preview", Static)
+
+        if not event.option or not event.option.id:
+            preview_widget.update("Select a session to preview")
+            return
+
+        session_id = str(event.option.id)
+        session_data = self._session_map.get(session_id)
+        if not session_data:
+            preview_widget.update("Session not found")
+            return
+
+        file_path = session_data.get("file_path")
+        if not file_path:
+            preview_widget.update("No preview available")
+            return
+
+        preview_text = self._load_preview(Path(file_path))
+        preview_widget.update(preview_text)
+
+    def _load_preview(self, file_path: Path) -> str:
+        """Load first 3 user messages from session file for preview."""
+        try:
+            with open(file_path) as f:
+                data = json.load(f)
+        except Exception:
+            return "Could not load preview"
+
+        messages = data.get("messages", [])
+        previews: list[str] = []
+
+        for msg in messages:
+            if len(previews) >= 3:
+                break
+
+            if not isinstance(msg, dict):
+                continue
+
+            # Only show request messages
+            if msg.get("kind") != "request":
+                continue
+
+            # Extract user-prompt parts only (skip system-prompt)
+            content = self._extract_user_content(msg)
+            if not content:
+                continue
+
+            # Truncate long messages
+            if len(content) > 60:
+                content = content[:57] + "..."
+            previews.append(f"> {content}")
+
+        if not previews:
+            return "No messages to preview"
+
+        return "\n".join(previews)
+
+    def _extract_user_content(self, msg: dict) -> str:
+        """Extract only user-prompt content from a message."""
+        parts = msg.get("parts", [])
+        user_parts: list[str] = []
+
+        for part in parts:
+            if not isinstance(part, dict):
+                continue
+            # Only include user-prompt parts, skip system-prompt
+            if part.get("part_kind") != "user-prompt":
+                continue
+            content = part.get("content", "")
+            if content:
+                user_parts.append(str(content))
+
+        return " ".join(user_parts)
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        """Confirm selection and dismiss with session ID."""
+        if event.option and event.option.id:
+            self.dismiss(str(event.option.id))
+
+    def action_cancel(self) -> None:
+        """Cancel selection."""
+        self.dismiss(None)

tunacode/ui/screens/setup.py

@@ -0,0 +1,218 @@
+"""Setup screen for TunaCode first-time configuration."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.screen import Screen
+from textual.widgets import Button, Input, Label, Select, Static
+
+from tunacode.configuration.models import (
+    get_models_for_provider,
+    get_provider_base_url,
+    get_provider_env_var,
+    get_providers,
+)
+from tunacode.constants import SETTINGS_BASE_URL
+from tunacode.utils.config import save_config
+
+if TYPE_CHECKING:
+    from tunacode.core.state import StateManager
+
+
+class SetupScreen(Screen[bool]):
+    """Setup wizard screen for first-time configuration."""
+
+    CSS = """
+    SetupScreen {
+        align: center middle;
+    }
+
+    #setup-container {
+        width: 70;
+        height: auto;
+        border: solid $primary;
+        background: $surface;
+        padding: 1 2;
+    }
+
+    #setup-title {
+        text-style: bold;
+        color: $accent;
+        text-align: center;
+        margin-bottom: 1;
+    }
+
+    #setup-subtitle {
+        color: $text-muted;
+        text-align: center;
+        margin-bottom: 1;
+    }
+
+    .field-label {
+        margin-top: 1;
+        color: $text;
+    }
+
+    #provider-select {
+        width: 100%;
+        margin-bottom: 1;
+    }
+
+    #model-select {
+        width: 100%;
+        margin-bottom: 1;
+    }
+
+    #api-key-input {
+        width: 100%;
+        margin-bottom: 1;
+    }
+
+    #button-row {
+        margin-top: 1;
+        align: center middle;
+    }
+
+    #save-button {
+        margin-right: 2;
+    }
+
+    #skip-button {
+        margin-left: 2;
+    }
+
+    #error-label {
+        color: $error;
+        text-align: center;
+        margin-top: 1;
+    }
+    """
+
+    BINDINGS = [
+        ("escape", "skip", "Skip Setup"),
+    ]
+
+    def __init__(self, state_manager: StateManager) -> None:
+        super().__init__()
+        self.state_manager = state_manager
+        self._selected_provider: str = ""
+
+    def compose(self) -> ComposeResult:
+        providers = get_providers()
+        has_openai = any(p[1] == "openai" for p in providers)
+        default_provider = "openai" if has_openai else (providers[0][1] if providers else "")
+
+        with Vertical(id="setup-container"):
+            yield Static("TunaCode Setup", id="setup-title")
+            yield Static("Configure your AI provider to get started.", id="setup-subtitle")
+
+            yield Label("Provider:", classes="field-label")
+            yield Select(
+                options=providers,
+                value=default_provider,
+                id="provider-select",
+                allow_blank=False,
+            )
+
+            yield Label("Model:", classes="field-label")
+            initial_models = get_models_for_provider(default_provider) if default_provider else []
+            yield Select(
+                options=initial_models,
+                value=initial_models[0][1] if initial_models else Select.BLANK,
+                id="model-select",
+                allow_blank=False,
+            )
+
+            yield Label("API Key:", classes="field-label")
+            yield Input(
+                placeholder="Enter your API key",
+                password=True,
+                id="api-key-input",
+            )
+
+            yield Static("", id="error-label")
+
+            with Horizontal(id="button-row"):
+                yield Button("Save & Start", variant="success", id="save-button")
+                yield Button("Skip", variant="default", id="skip-button")
+
+        self._selected_provider = default_provider
+
+    def on_select_changed(self, event: Select.Changed) -> None:
+        """Update model options when provider changes."""
+        if event.select.id != "provider-select":
+            return
+
+        provider = str(event.value)
+        self._selected_provider = provider
+
+        models = get_models_for_provider(provider)
+        model_select = self.query_one("#model-select", Select)
+        model_select.set_options(models)
+
+        if models:
+            model_select.value = models[0][1]
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle button presses."""
+        if event.button.id == "save-button":
+            self._save_and_dismiss()
+        elif event.button.id == "skip-button":
+            self.dismiss(False)
+
+    def action_skip(self) -> None:
+        """Skip setup without saving."""
+        self.dismiss(False)
+
+    def _save_and_dismiss(self) -> None:
+        """Validate inputs, save config, and dismiss screen."""
+        error_label = self.query_one("#error-label", Static)
+        error_label.update("")
+
+        provider_select = self.query_one("#provider-select", Select)
+        model_select = self.query_one("#model-select", Select)
+        api_key_input = self.query_one("#api-key-input", Input)
+
+        provider = str(provider_select.value) if provider_select.value != Select.BLANK else ""
+        model = str(model_select.value) if model_select.value != Select.BLANK else ""
+        api_key = api_key_input.value.strip()
+
+        if not provider:
+            error_label.update("Please select a provider")
+            return
+
+        if not model:
+            error_label.update("Please select a model")
+            return
+
+        if not api_key:
+            error_label.update("API key is required")
+            return
+
+        full_model = f"{provider}:{model}"
+        env_var = get_provider_env_var(provider)
+        base_url = get_provider_base_url(provider)
+
+        user_config = self.state_manager.session.user_config
+        user_config["default_model"] = full_model
+
+        if "env" not in user_config:
+            user_config["env"] = {}
+        user_config["env"][env_var] = api_key
+
+        if base_url:
+            if "settings" not in user_config:
+                user_config["settings"] = {}
+            user_config["settings"][SETTINGS_BASE_URL] = base_url
+
+        self.state_manager.session.current_model = full_model
+
+        try:
+            save_config(self.state_manager)
+            self.notify("Configuration saved!", severity="information")
+            self.dismiss(True)
+        except Exception as e:
+            error_label.update(f"Failed to save: {e}")

tunacode/ui/screens/theme_picker.py

@@ -0,0 +1,90 @@
+"""Theme picker modal screen for TunaCode."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.screen import Screen
+from textual.widgets import OptionList, Static
+from textual.widgets.option_list import Option
+
+if TYPE_CHECKING:
+    from textual.theme import Theme
+
+
+class ThemePickerScreen(Screen[str | None]):
+    """Modal screen for theme selection with live preview."""
+
+    CSS = """
+    ThemePickerScreen {
+        align: center middle;
+    }
+
+    #theme-container {
+        width: 40;
+        height: auto;
+        max-height: 20;
+        border: solid $primary;
+        background: $surface;
+        padding: 1 2;
+    }
+
+    #theme-title {
+        text-style: bold;
+        color: $accent;
+        text-align: center;
+        margin-bottom: 1;
+    }
+
+    #theme-list {
+        height: auto;
+        max-height: 14;
+    }
+    """
+
+    BINDINGS = [
+        ("escape", "cancel", "Cancel"),
+    ]
+
+    def __init__(
+        self,
+        themes: dict[str, Theme],
+        current_theme: str,
+    ) -> None:
+        super().__init__()
+        self._themes = themes
+        self._current_theme = current_theme
+        self._original_theme = current_theme
+
+    def compose(self) -> ComposeResult:
+        options = []
+        highlight_index = 0
+
+        for i, (name, theme) in enumerate(sorted(self._themes.items())):
+            label = f"{name} ({'Dark' if theme.dark else 'Light'})"
+            options.append(Option(label, id=name))
+            if name == self._current_theme:
+                highlight_index = i
+
+        with Vertical(id="theme-container"):
+            yield Static("Select Theme", id="theme-title")
+            option_list = OptionList(*options, id="theme-list")
+            option_list.highlighted = highlight_index
+            yield option_list
+
+    def on_option_list_option_highlighted(self, event: OptionList.OptionHighlighted) -> None:
+        """Live preview: change theme as user navigates."""
+        if event.option and event.option.id:
+            self.app.theme = str(event.option.id)
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        """Confirm selection and dismiss."""
+        if event.option and event.option.id:
+            self.dismiss(str(event.option.id))
+
+    def action_cancel(self) -> None:
+        """Cancel and revert to original theme."""
+        self.app.theme = self._original_theme
+        self.dismiss(None)

tunacode/ui/screens/update_confirm.py

@@ -0,0 +1,69 @@
+"""Update confirmation screen for TunaCode."""
+
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.screen import Screen
+from textual.widgets import Static
+
+# Modal layout constants
+MODAL_WIDTH = 50
+MODAL_PADDING_VERTICAL = 1
+MODAL_PADDING_HORIZONTAL = 2
+SECTION_MARGIN_BOTTOM = 1
+
+
+class UpdateConfirmScreen(Screen[bool]):
+    """Modal screen to confirm update installation."""
+
+    CSS = f"""
+    UpdateConfirmScreen {{
+        align: center middle;
+    }}
+
+    #update-container {{
+        width: {MODAL_WIDTH};
+        height: auto;
+        border: solid $primary;
+        background: $surface;
+        padding: {MODAL_PADDING_VERTICAL} {MODAL_PADDING_HORIZONTAL};
+    }}
+
+    #update-title {{
+        text-style: bold;
+        color: $accent;
+        text-align: center;
+        margin-bottom: {SECTION_MARGIN_BOTTOM};
+    }}
+
+    #update-info {{
+        margin-bottom: {SECTION_MARGIN_BOTTOM};
+    }}
+    """
+
+    BINDINGS = [
+        ("escape", "cancel", "Cancel"),
+        ("y", "confirm", "Yes"),
+        ("n", "cancel", "No"),
+    ]
+
+    def __init__(self, current_version: str, latest_version: str) -> None:
+        super().__init__()
+        self._current = current_version
+        self._latest = latest_version
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="update-container"):
+            yield Static("Update Available", id="update-title")
+            yield Static(
+                f"Current: {self._current}\nLatest:  {self._latest}",
+                id="update-info",
+            )
+            yield Static("Install update? (y/n)")
+
+    def action_confirm(self) -> None:
+        self.dismiss(True)
+
+    def action_cancel(self) -> None:
+        self.dismiss(False)

tunacode/ui/shell_runner.py

@@ -0,0 +1,129 @@
+"""Async shell command runner for the Textual TUI."""
+
+from __future__ import annotations
+
+import asyncio
+import signal
+import subprocess
+from dataclasses import dataclass
+from typing import Protocol
+
+from rich.text import Text
+
+SHELL_COMMAND_TIMEOUT_SECONDS: float = 30.0
+SHELL_COMMAND_CANCEL_GRACE_SECONDS: float = 0.5
+SHELL_COMMAND_USAGE_TEXT = "Usage: !<command>"
+SHELL_OUTPUT_ENCODING = "utf-8"
+SHELL_CANCEL_SIGNAL = signal.SIGINT
+
+
+class ShellRunnerHost(Protocol):
+    def notify(self, message: str, severity: str = "information") -> None: ...
+
+    def write_shell_output(self, renderable: Text) -> None: ...
+
+    def shell_status_running(self) -> None: ...
+
+    def shell_status_last(self) -> None: ...
+
+
+@dataclass
+class ShellRunner:
+    host: ShellRunnerHost
+
+    _task: asyncio.Task[None] | None = None
+    _process: asyncio.subprocess.Process | None = None
+
+    def is_running(self) -> bool:
+        return self._task is not None and not self._task.done()
+
+    def start(self, raw_cmd: str) -> None:
+        cmd = raw_cmd.strip()
+        if not cmd:
+            self.host.notify(SHELL_COMMAND_USAGE_TEXT, severity="warning")
+            return
+
+        if self.is_running():
+            self.host.notify(
+                "Shell command already running (! or Esc to cancel)",
+                severity="warning",
+            )
+            return
+
+        self._task = asyncio.create_task(self._run(cmd))
+        self._task.add_done_callback(self._on_done)
+
+    def cancel(self) -> None:
+        if not self.is_running():
+            return
+
+        process = self._process
+        if process is None:
+            assert self._task is not None
+            self._task.cancel()
+            return
+
+        try:
+            process.send_signal(SHELL_CANCEL_SIGNAL)
+        except ProcessLookupError:
+            assert self._task is not None
+            self._task.cancel()
+            return
+
+        assert self._task is not None
+        self._task.cancel()
+
+    def _on_done(self, task: asyncio.Task[None]) -> None:
+        try:
+            task.result()
+        except asyncio.CancelledError:
+            return
+        except Exception as exc:
+            self.host.write_shell_output(Text(f"Shell error: {exc}"))
+
+    async def _wait_or_kill_process(self, process: asyncio.subprocess.Process) -> None:
+        if process.returncode is not None:
+            return
+
+        try:
+            await asyncio.wait_for(process.wait(), timeout=SHELL_COMMAND_CANCEL_GRACE_SECONDS)
+        except TimeoutError:
+            process.kill()
+            await process.wait()
+
+    async def _run(self, cmd: str) -> None:
+        self.host.shell_status_running()
+        self.host.notify(f"Running: {cmd}")
+
+        process = await asyncio.create_subprocess_shell(
+            cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.STDOUT,
+            stdin=subprocess.DEVNULL,
+        )
+        self._process = process
+
+        try:
+            stdout, _ = await asyncio.wait_for(
+                process.communicate(),
+                timeout=SHELL_COMMAND_TIMEOUT_SECONDS,
+            )
+        except TimeoutError:
+            process.kill()
+            await process.wait()
+            self.host.notify("Command timed out", severity="error")
+            return
+        except asyncio.CancelledError:
+            await self._wait_or_kill_process(process)
+            self.host.notify("Shell command cancelled", severity="warning")
+            raise
+        finally:
+            self._process = None
+            self.host.shell_status_last()
+
+        output = (stdout or b"").decode(SHELL_OUTPUT_ENCODING, errors="replace").rstrip()
+        if output:
+            self.host.write_shell_output(Text(output))
+
+        if process.returncode is not None and process.returncode != 0:
+            self.host.notify(f"Exit code: {process.returncode}", severity="warning")