tunacode-cli 0.1.21__py3-none-any.whl

tunacode/ui/repl_support.py

@@ -0,0 +1,226 @@
+"""Support helpers for the Textual REPL app.
+
+This module exists to keep `tunacode.ui.app` focused on UI composition and lifecycle
+while hosting small, testable helpers and callback builders.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import re
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from typing import Any, Protocol
+
+from rich.console import Console
+from rich.text import Text
+
+from tunacode.constants import MAX_CALLBACK_CONTENT
+from tunacode.tools.authorization.handler import ToolHandler
+from tunacode.types import (
+    StateManager,
+    ToolConfirmationRequest,
+    ToolConfirmationResponse,
+    ToolProgress,
+    ToolProgressCallback,
+)
+from tunacode.ui.widgets import ToolResultDisplay
+
+COLLAPSE_THRESHOLD: int = 10
+
+FILE_EDIT_TOOLS: frozenset[str] = frozenset({"write_file", "update_file"})
+
+USER_MESSAGE_PREFIX: str = "│ "
+DEFAULT_USER_MESSAGE_WIDTH: int = 80
+DIAGNOSTICS_BLOCK_START: str = "<file_diagnostics>"
+DIAGNOSTICS_BLOCK_END: str = "</file_diagnostics>"
+DIAGNOSTICS_BLOCK_PATTERN: str = f"{DIAGNOSTICS_BLOCK_START}.*?{DIAGNOSTICS_BLOCK_END}"
+DIAGNOSTICS_BLOCK_RE = re.compile(DIAGNOSTICS_BLOCK_PATTERN, re.DOTALL)
+CALLBACK_TRUNCATION_NOTICE: str = "\n... [truncated for safety]"
+CALLBACK_TRUNCATION_NOTICE_LEN: int = len(CALLBACK_TRUNCATION_NOTICE)
+
+logger = logging.getLogger(__name__)
+
+
+def _format_prefixed_wrapped_lines(
+    lines: list[tuple[str, str]],
+    *,
+    width: int,
+) -> Text:
+    effective_width = width if width > 0 else DEFAULT_USER_MESSAGE_WIDTH
+    content_width = max(1, effective_width - len(USER_MESSAGE_PREFIX))
+    console = Console(width=content_width, color_system=None, force_terminal=False)
+
+    block = Text()
+    for line_text, line_style in lines:
+        wrapped_lines = Text(line_text, style=line_style, overflow="fold").wrap(
+            console, content_width
+        )
+        for wrapped in wrapped_lines:
+            block.append(USER_MESSAGE_PREFIX, style=line_style)
+            block.append_text(wrapped)
+            block.append("\n")
+    return block
+
+
+def format_user_message(text: str, style: str, *, width: int) -> Text:
+    """Format user text with left gutter prefix and hard-wrap for terminal width."""
+    lines = text.splitlines() or [""]
+    styled_lines = [(line, style) for line in lines]
+    return _format_prefixed_wrapped_lines(styled_lines, width=width)
+
+
+def format_collapsed_message(text: str, style: str, *, width: int) -> Text:
+    """Format long pasted text with a collapsed middle section.
+
+    Shows first 3 lines, collapse indicator, and last 2 lines.
+    """
+    lines = text.splitlines()
+    line_count = max(1, len(lines))
+
+    if line_count <= COLLAPSE_THRESHOLD:
+        return format_user_message(text, style, width=width)
+
+    collapsed = line_count - 5
+
+    render_lines: list[tuple[str, str]] = [(line, style) for line in lines[:3]]
+    render_lines.append((f"[[ {collapsed} more lines ]]", f"dim {style}"))
+    render_lines.extend((line, style) for line in lines[-2:])
+    return _format_prefixed_wrapped_lines(render_lines, width=width)
+
+
+@dataclass
+class PendingConfirmationState:
+    """Tracks pending tool confirmation state."""
+
+    future: asyncio.Future[ToolConfirmationResponse]
+    request: ToolConfirmationRequest
+
+
+class ConfirmationRequester(Protocol):
+    async def request_tool_confirmation(
+        self, request: ToolConfirmationRequest
+    ) -> ToolConfirmationResponse: ...
+
+
+class StatusBarLike(Protocol):
+    def add_edited_file(self, filepath: str) -> None: ...
+
+    def update_last_action(self, tool_name: str) -> None: ...
+
+    def update_running_action(self, tool_name: str) -> None: ...
+
+    def update_subagent_progress(self, progress: ToolProgress) -> None: ...
+
+
+class AppForCallbacks(ConfirmationRequester, Protocol):
+    status_bar: StatusBarLike
+
+    def post_message(self, message: ToolResultDisplay) -> None: ...
+
+
+def build_textual_tool_callback(
+    app: ConfirmationRequester,
+    state_manager: StateManager,
+) -> Callable[[Any, Any | None], Awaitable[None]]:
+    async def _callback(part: Any, _node: Any = None) -> None:
+        tool_handler = state_manager.tool_handler or ToolHandler(state_manager)
+        state_manager.set_tool_handler(tool_handler)
+
+        if not tool_handler.should_confirm(part.tool_name):
+            return
+
+        from tunacode.exceptions import UserAbortError
+        from tunacode.utils.parsing.command_parser import parse_args
+
+        args = parse_args(part.args)
+        request = tool_handler.create_confirmation_request(part.tool_name, args)
+        response = await app.request_tool_confirmation(request)
+        if not tool_handler.process_confirmation(response, part.tool_name):
+            raise UserAbortError("User aborted tool execution")
+
+    return _callback
+
+
+def _truncate_for_safety(content: str | None) -> str | None:
+    """Emergency truncation - prevents UI freeze on massive outputs."""
+    if content is None:
+        return None
+    if len(content) <= MAX_CALLBACK_CONTENT:
+        return content
+
+    diagnostics_match = DIAGNOSTICS_BLOCK_RE.match(content)
+    if diagnostics_match is None:
+        if content.startswith(DIAGNOSTICS_BLOCK_START):
+            logger.warning("Diagnostics block missing closing tag; truncating content.")
+        truncation_limit = MAX_CALLBACK_CONTENT - CALLBACK_TRUNCATION_NOTICE_LEN
+        return content[:truncation_limit] + CALLBACK_TRUNCATION_NOTICE
+
+    diagnostics_block = diagnostics_match.group(0)
+    remaining_content = content[len(diagnostics_block) :]
+    diagnostics_len = len(diagnostics_block)
+    remaining_budget = MAX_CALLBACK_CONTENT - diagnostics_len - CALLBACK_TRUNCATION_NOTICE_LEN
+
+    if remaining_budget <= 0:
+        logger.warning("Diagnostics block exceeds safety limit; truncating remainder.")
+        return diagnostics_block + CALLBACK_TRUNCATION_NOTICE
+
+    truncated_remainder = remaining_content[:remaining_budget]
+    truncated_result = f"{diagnostics_block}{truncated_remainder}{CALLBACK_TRUNCATION_NOTICE}"
+    return truncated_result
+
+
+def build_tool_result_callback(app: AppForCallbacks) -> Callable[..., None]:
+    def _callback(
+        tool_name: str,
+        status: str,
+        args: dict[str, Any],
+        result: str | None = None,
+        duration_ms: float | None = None,
+    ) -> None:
+        if tool_name in FILE_EDIT_TOOLS and status == "completed":
+            filepath = args.get("filepath")
+            if filepath:
+                app.status_bar.add_edited_file(filepath)
+
+        app.status_bar.update_last_action(tool_name)
+
+        safe_result = _truncate_for_safety(result)
+
+        app.post_message(
+            ToolResultDisplay(
+                tool_name=tool_name,
+                status=status,
+                args=args,
+                result=safe_result,
+                duration_ms=duration_ms,
+            )
+        )
+
+    return _callback
+
+
+def build_tool_start_callback(app: AppForCallbacks) -> Callable[[str], None]:
+    """Build callback for tool start notifications."""
+
+    def _callback(tool_name: str) -> None:
+        app.status_bar.update_running_action(tool_name)
+
+    return _callback
+
+
+def build_tool_progress_callback(app: AppForCallbacks) -> ToolProgressCallback:
+    """Build callback for subagent tool progress notifications."""
+
+    def _callback(progress: ToolProgress) -> None:
+        app.status_bar.update_subagent_progress(progress)
+
+    return _callback
+
+
+async def run_textual_repl(state_manager: StateManager, show_setup: bool = False) -> None:
+    from tunacode.ui.app import TextualReplApp
+
+    app = TextualReplApp(state_manager=state_manager, show_setup=show_setup)
+    await app.run_async()

tunacode/ui/screens/__init__.py

@@ -0,0 +1,16 @@
+"""Textual screens for TunaCode REPL."""
+
+from tunacode.ui.screens.model_picker import ModelPickerScreen, ProviderPickerScreen
+from tunacode.ui.screens.session_picker import SessionPickerScreen
+from tunacode.ui.screens.setup import SetupScreen
+from tunacode.ui.screens.theme_picker import ThemePickerScreen
+from tunacode.ui.screens.update_confirm import UpdateConfirmScreen
+
+__all__ = [
+    "ModelPickerScreen",
+    "ProviderPickerScreen",
+    "SessionPickerScreen",
+    "SetupScreen",
+    "ThemePickerScreen",
+    "UpdateConfirmScreen",
+]

tunacode/ui/screens/model_picker.py

@@ -0,0 +1,303 @@
+"""Model picker modal screens for TunaCode."""
+
+from __future__ import annotations
+
+from textual import events
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.screen import Screen
+from textual.widgets import Input, OptionList, Static
+from textual.widgets.option_list import Option
+
+from tunacode.configuration.models import get_models_for_provider, get_providers
+from tunacode.constants import MODEL_PICKER_UNFILTERED_LIMIT
+
+
+def _filter_visible_items(
+    items: list[tuple[str, str]],
+    filter_query: str,
+    limit: int,
+) -> tuple[list[tuple[str, str]], bool]:
+    normalized_query = filter_query.strip().lower()
+    has_query = bool(normalized_query)
+    visible_items: list[tuple[str, str]] = []
+    total_matches = 0
+
+    for display_name, item_id in items:
+        display_name_lower = display_name.lower()
+        if has_query and normalized_query not in display_name_lower:
+            continue
+        total_matches += 1
+        if not has_query and len(visible_items) >= limit:
+            continue
+        visible_items.append((display_name, item_id))
+
+    is_truncated = (not has_query) and (total_matches > len(visible_items))
+    return visible_items, is_truncated
+
+
+def _choose_highlight_index(
+    items: list[tuple[str, str]],
+    current_id: str,
+) -> int | None:
+    if not items:
+        return None
+
+    for index, (_, item_id) in enumerate(items):
+        if item_id == current_id:
+            return index
+
+    return 0
+
+
+def _append_truncation_notice(option_list: OptionList, limit: int, label: str) -> None:
+    message = f"Showing first {limit} {label}. Type to filter to see more."
+    option_list.add_option(Option(message, disabled=True))
+
+
+class ProviderPickerScreen(Screen[str | None]):
+    """Modal screen for provider selection (step 1 of model picker)."""
+
+    CSS = """
+    ProviderPickerScreen {
+        align: center middle;
+    }
+
+    #provider-container {
+        width: 50;
+        height: auto;
+        max-height: 28;
+        border: solid $primary;
+        background: $surface;
+        padding: 1 2;
+    }
+
+    #provider-title {
+        text-style: bold;
+        color: $accent;
+        text-align: center;
+        margin-bottom: 1;
+    }
+
+    #provider-filter {
+        height: 3;
+        margin-bottom: 1;
+    }
+
+    #provider-list {
+        height: auto;
+        max-height: 18;
+    }
+    """
+
+    BINDINGS = [
+        ("escape", "cancel", "Cancel"),
+    ]
+
+    def __init__(self, current_model: str) -> None:
+        super().__init__()
+        self._current_model = current_model
+        self._current_provider = current_model.split(":")[0] if ":" in current_model else ""
+        self._all_providers: list[tuple[str, str]] = []
+        self._filter_query: str = ""
+
+    def compose(self) -> ComposeResult:
+        self._all_providers = get_providers()
+
+        with Vertical(id="provider-container"):
+            yield Static("Select Provider", id="provider-title")
+            yield Input(placeholder="Filter providers...", id="provider-filter")
+            yield OptionList(id="provider-list")
+
+        self.call_after_refresh(self._rebuild_options)
+
+    def _rebuild_options(self) -> None:
+        """Rebuild OptionList with filtered items."""
+        option_list = self.query_one("#provider-list", OptionList)
+        option_list.clear_options()
+
+        filter_query = self._filter_query
+        visible_providers, is_truncated = _filter_visible_items(
+            self._all_providers,
+            filter_query,
+            MODEL_PICKER_UNFILTERED_LIMIT,
+        )
+
+        highlight_index = _choose_highlight_index(visible_providers, self._current_provider)
+
+        for display_name, provider_id in visible_providers:
+            option_list.add_option(Option(display_name, id=provider_id))
+
+        if highlight_index is not None:
+            option_list.highlighted = highlight_index
+
+        if is_truncated:
+            _append_truncation_notice(
+                option_list,
+                MODEL_PICKER_UNFILTERED_LIMIT,
+                "providers",
+            )
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        """Filter options as user types."""
+        if event.input.id != "provider-filter":
+            return
+        self._filter_query = event.value
+        self._rebuild_options()
+
+    def on_key(self, event: events.Key) -> None:
+        """Handle focus transitions between Input and OptionList."""
+        filter_input = self.query_one("#provider-filter", Input)
+        option_list = self.query_one("#provider-list", OptionList)
+
+        if event.key == "down" and self.focused == filter_input:
+            self.set_focus(option_list)
+            event.stop()
+        elif event.key == "up" and self.focused == option_list:
+            if option_list.highlighted == 0:
+                self.set_focus(filter_input)
+                event.stop()
+        elif event.key == "escape" and self._filter_query:
+            filter_input.value = ""
+            self._filter_query = ""
+            self._rebuild_options()
+            event.stop()
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        """Confirm selection and dismiss with provider ID."""
+        if event.option and event.option.id:
+            self.dismiss(str(event.option.id))
+
+    def action_cancel(self) -> None:
+        """Cancel selection."""
+        self.dismiss(None)
+
+
+class ModelPickerScreen(Screen[str | None]):
+    """Modal screen for model selection (step 2 of model picker)."""
+
+    CSS = """
+    ModelPickerScreen {
+        align: center middle;
+    }
+
+    #model-container {
+        width: 60;
+        height: auto;
+        max-height: 28;
+        border: solid $primary;
+        background: $surface;
+        padding: 1 2;
+    }
+
+    #model-title {
+        text-style: bold;
+        color: $accent;
+        text-align: center;
+        margin-bottom: 1;
+    }
+
+    #model-filter {
+        height: 3;
+        margin-bottom: 1;
+    }
+
+    #model-list {
+        height: auto;
+        max-height: 18;
+    }
+    """
+
+    BINDINGS = [
+        ("escape", "cancel", "Cancel"),
+    ]
+
+    def __init__(self, provider_id: str, current_model: str) -> None:
+        super().__init__()
+        self._provider_id = provider_id
+        self._current_model = current_model
+        current_model_id = current_model.split(":", 1)[1] if ":" in current_model else ""
+        self._current_model_id = current_model_id
+        self._all_models: list[tuple[str, str]] = []
+        self._filter_query: str = ""
+
+    def compose(self) -> ComposeResult:
+        self._all_models = get_models_for_provider(self._provider_id)
+
+        with Vertical(id="model-container"):
+            yield Static(f"Select Model ({self._provider_id})", id="model-title")
+            yield Input(placeholder="Filter models...", id="model-filter")
+            yield OptionList(id="model-list")
+
+        self.call_after_refresh(self._rebuild_options)
+
+    def _rebuild_options(self) -> None:
+        """Rebuild OptionList with filtered items and pricing."""
+        from tunacode.configuration.pricing import format_pricing_display, get_model_pricing
+
+        option_list = self.query_one("#model-list", OptionList)
+        option_list.clear_options()
+
+        filter_query = self._filter_query
+        visible_models, is_truncated = _filter_visible_items(
+            self._all_models,
+            filter_query,
+            MODEL_PICKER_UNFILTERED_LIMIT,
+        )
+
+        highlight_index = _choose_highlight_index(visible_models, self._current_model_id)
+
+        for display_name, model_id in visible_models:
+            full_model = f"{self._provider_id}:{model_id}"
+            pricing = get_model_pricing(full_model)
+            if pricing is not None:
+                label = f"{display_name}  {format_pricing_display(pricing)}"
+            else:
+                label = display_name
+
+            option_list.add_option(Option(label, id=model_id))
+
+        if highlight_index is not None:
+            option_list.highlighted = highlight_index
+
+        if is_truncated:
+            _append_truncation_notice(
+                option_list,
+                MODEL_PICKER_UNFILTERED_LIMIT,
+                "models",
+            )
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        """Filter options as user types."""
+        if event.input.id != "model-filter":
+            return
+        self._filter_query = event.value
+        self._rebuild_options()
+
+    def on_key(self, event: events.Key) -> None:
+        """Handle focus transitions between Input and OptionList."""
+        filter_input = self.query_one("#model-filter", Input)
+        option_list = self.query_one("#model-list", OptionList)
+
+        if event.key == "down" and self.focused == filter_input:
+            self.set_focus(option_list)
+            event.stop()
+        elif event.key == "up" and self.focused == option_list:
+            if option_list.highlighted == 0:
+                self.set_focus(filter_input)
+                event.stop()
+        elif event.key == "escape" and self._filter_query:
+            filter_input.value = ""
+            self._filter_query = ""
+            self._rebuild_options()
+            event.stop()
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        """Confirm selection and dismiss with full model string."""
+        if event.option and event.option.id:
+            full_model = f"{self._provider_id}:{event.option.id}"
+            self.dismiss(full_model)
+
+    def action_cancel(self) -> None:
+        """Cancel selection."""
+        self.dismiss(None)