tunacode-cli 0.0.71__py3-none-any.whl → 0.0.72__py3-none-any.whl

tunacode/ui/completers.py

@@ -1,7 +1,7 @@
 """Completers for file references and commands."""
 
 import os
-from typing import TYPE_CHECKING, Iterable, Optional
+from typing import TYPE_CHECKING, Iterable, List, Optional
 
 from prompt_toolkit.completion import (
     CompleteEvent,
@@ -13,6 +13,7 @@ from prompt_toolkit.document import Document
 
 if TYPE_CHECKING:
     from ..cli.commands import CommandRegistry
+    from ..utils.models_registry import ModelInfo, ModelsRegistry
 
 
 class CommandCompleter(Completer):
@@ -126,11 +127,212 @@ class FileReferenceCompleter(Completer):
             pass
 
 
-def create_completer(command_registry: Optional["CommandRegistry"] = None) -> Completer:
-    """Create a merged completer for both commands and file references."""
-    return merge_completers(
-        [
-            CommandCompleter(command_registry),
-            FileReferenceCompleter(),
-        ]
-    )
+class ModelCompleter(Completer):
+    """Completer for model names in /model command."""
+
+    def __init__(self, registry: Optional["ModelsRegistry"] = None):
+        """Initialize the model completer."""
+        self.registry = registry
+        self._models_cache: Optional[List[ModelInfo]] = None
+        self._registry_loaded = False
+
+    async def _ensure_registry_loaded(self):
+        """Ensure the models registry is loaded."""
+        if self.registry and not self._registry_loaded:
+            try:
+                # Try to load models (this will be fast if already loaded)
+                await self.registry.load()
+                self._registry_loaded = True
+                self._models_cache = (
+                    list(self.registry.models.values()) if self.registry.models else []
+                )
+            except Exception:
+                # If loading fails, use empty cache
+                self._models_cache = []
+                self._registry_loaded = True
+
+    def get_completions(
+        self, document: Document, _complete_event: CompleteEvent
+    ) -> Iterable[Completion]:
+        """Get completions for model names."""
+        if not self.registry:
+            return
+
+        text = document.text_before_cursor
+
+        # Check if we're in a /model command context
+        lines = text.split("\n")
+        current_line = lines[-1].strip()
+
+        # Must start with /model
+        if not current_line.startswith("/model"):
+            return
+
+        # Try to load registry synchronously if not loaded
+        # Note: This is a compromise - ideally we'd use async completion
+        if not self._registry_loaded:
+            try:
+                # Quick attempt to load cached data only
+                if self.registry._is_cache_valid() and self.registry._load_from_cache():
+                    self._registry_loaded = True
+                    self._models_cache = list(self.registry.models.values())
+                elif not self._models_cache:
+                    # Use fallback models for immediate completion
+                    self.registry._load_fallback_models()
+                    self._registry_loaded = True
+                    self._models_cache = list(self.registry.models.values())
+            except Exception:
+                return  # Skip completion if we can't load models
+
+        # Get the part after /model
+        parts = current_line.split()
+        if len(parts) < 2:
+            # Just "/model" - suggest popular searches and top models
+            popular_searches = ["claude", "gpt", "gemini", "openai", "anthropic"]
+            for search_term in popular_searches:
+                yield Completion(
+                    text=search_term, display=f"{search_term} (search)", display_meta="search term"
+                )
+
+            # Also show top 3 most popular models if we have them
+            if self._models_cache:
+                popular_models = []
+                # Look for common popular models
+                for model in self._models_cache:
+                    if any(pop in model.id.lower() for pop in ["gpt-4o", "claude-3", "gemini-2"]):
+                        popular_models.append(model)
+                        if len(popular_models) >= 3:
+                            break
+
+                for model in popular_models:
+                    display = f"{model.full_id} - {model.name}"
+                    if model.cost.input is not None:
+                        display += f" (${model.cost.input}/{model.cost.output})"
+
+                    yield Completion(
+                        text=model.full_id, display=display, display_meta=f"{model.provider} model"
+                    )
+            return
+
+        # Get the current word being typed
+        word_before_cursor = document.get_word_before_cursor(WORD=True)
+        if not word_before_cursor or not self._models_cache:
+            return
+
+        query = word_before_cursor.lower()
+
+        # Use the new grouped approach to find base models with variants
+        base_models = self.registry.find_base_models(query)
+
+        if not base_models:
+            return
+
+        results = []
+        shown_base_models = 0
+
+        # Sort base models by popularity/relevance
+        sorted_base_models = sorted(
+            base_models.items(),
+            key=lambda x: (
+                # Popular models first
+                -1
+                if any(
+                    pop in x[0] for pop in ["gpt-4o", "gpt-4", "claude-3", "gemini-2", "o3", "o1"]
+                )
+                else 0,
+                # Then by name
+                x[0],
+            ),
+        )
+
+        for base_model_name, variants in sorted_base_models:
+            if shown_base_models >= 5:  # Limit to top 5 base models
+                break
+
+            shown_variants = 0
+            for i, model in enumerate(variants):
+                if shown_variants >= 3:  # Show max 3 variants per base model
+                    break
+
+                # Calculate start position for replacement
+                start_pos = -len(word_before_cursor)
+
+                # Build display text with enhanced info
+                cost_str = ""
+                if model.cost.input is not None:
+                    if model.cost.input == 0:
+                        cost_str = " (FREE)"
+                    else:
+                        cost_str = f" (${model.cost.input}/{model.cost.output})"
+
+                # Format provider info
+                provider_display = self._get_provider_display_name(model.provider)
+
+                # Primary variant gets the bullet, others get indentation
+                if i == 0:
+                    # First variant - primary option with bullet
+                    display = f"● {model.full_id} - {model.name}{cost_str}"
+                    if model.cost.input == 0:
+                        display += " ⭐"  # Star for free models
+                else:
+                    # Additional variants - indented
+                    display = f"   {model.full_id} - {model.name}{cost_str}"
+                    if model.cost.input == 0:
+                        display += " ⭐"
+
+                meta_info = f"{provider_display}"
+                if len(variants) > 1:
+                    meta_info += f" ({len(variants)} sources)"
+
+                results.append(
+                    Completion(
+                        text=model.full_id,
+                        start_position=start_pos,
+                        display=display,
+                        display_meta=meta_info,
+                    )
+                )
+
+                shown_variants += 1
+
+            shown_base_models += 1
+
+        # Limit total results for readability
+        for completion in results[:20]:
+            yield completion
+
+    def _get_provider_display_name(self, provider: str) -> str:
+        """Get a user-friendly provider display name."""
+        provider_names = {
+            "openai": "OpenAI Direct",
+            "anthropic": "Anthropic Direct",
+            "google": "Google Direct",
+            "google-gla": "Google Labs",
+            "openrouter": "OpenRouter",
+            "github-models": "GitHub Models (FREE)",
+            "azure": "Azure OpenAI",
+            "fastrouter": "FastRouter",
+            "requesty": "Requesty",
+            "cloudflare-workers-ai": "Cloudflare",
+            "amazon-bedrock": "AWS Bedrock",
+            "chutes": "Chutes AI",
+            "deepinfra": "DeepInfra",
+            "venice": "Venice AI",
+        }
+        return provider_names.get(provider, provider.title())
+
+
+def create_completer(
+    command_registry: Optional["CommandRegistry"] = None,
+    models_registry: Optional["ModelsRegistry"] = None,
+) -> Completer:
+    """Create a merged completer for commands, file references, and models."""
+    completers = [
+        CommandCompleter(command_registry),
+        FileReferenceCompleter(),
+    ]
+
+    if models_registry:
+        completers.append(ModelCompleter(models_registry))
+
+    return merge_completers(completers)

tunacode/ui/input.py

@@ -95,6 +95,12 @@ async def multiline_input(
         )
     )
 
+    # Create models registry for auto-completion (lazy loaded)
+    from ..utils.models_registry import ModelsRegistry
+
+    models_registry = ModelsRegistry()
+    # Note: Registry will be loaded lazily by the completer when needed
+
     # Display input area (Plan Mode indicator is handled dynamically in prompt manager)
     result = await input(
         "multiline",
@@ -102,7 +108,7 @@ async def multiline_input(
         key_bindings=kb,
         multiline=True,
         placeholder=placeholder,
-        completer=create_completer(command_registry),
+        completer=create_completer(command_registry, models_registry),
         lexer=FileReferenceLexer(),
         state_manager=state_manager,
     )

tunacode/ui/model_selector.py

@@ -0,0 +1,394 @@
+"""Interactive model selector UI component."""
+
+from typing import List, Optional
+
+from prompt_toolkit.application import Application
+from prompt_toolkit.buffer import Buffer
+from prompt_toolkit.formatted_text import HTML, StyleAndTextTuples
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.layout import (
+    FormattedTextControl,
+    HSplit,
+    Layout,
+    VSplit,
+    Window,
+    WindowAlign,
+)
+from prompt_toolkit.layout.controls import BufferControl
+from prompt_toolkit.layout.dimension import Dimension
+from prompt_toolkit.search import SearchState
+from prompt_toolkit.styles import Style
+from prompt_toolkit.widgets import Frame
+
+from ..utils.models_registry import ModelInfo, ModelsRegistry
+
+
+class ModelSelector:
+    """Interactive model selector with search and navigation."""
+
+    def __init__(self, registry: ModelsRegistry):
+        """Initialize the model selector."""
+        self.registry = registry
+        self.models: List[ModelInfo] = []
+        self.filtered_models: List[ModelInfo] = []
+        self.selected_index = 0
+        self.search_text = ""
+        self.selected_model: Optional[ModelInfo] = None
+
+        # Create key bindings
+        self.kb = self._create_key_bindings()
+
+        # Create search buffer
+        self.search_buffer = Buffer(on_text_changed=self._on_search_changed)
+
+        # Search state
+        self.search_state = SearchState()
+
+    def _create_key_bindings(self) -> KeyBindings:
+        """Create key bindings for the selector."""
+        kb = KeyBindings()
+
+        @kb.add("up", "k")
+        def move_up(event):
+            """Move selection up."""
+            if self.selected_index > 0:
+                self.selected_index -= 1
+                self._update_display()
+
+        @kb.add("down", "j")
+        def move_down(event):
+            """Move selection down."""
+            if self.selected_index < len(self.filtered_models) - 1:
+                self.selected_index += 1
+                self._update_display()
+
+        @kb.add("pageup")
+        def page_up(event):
+            """Move selection up by page."""
+            self.selected_index = max(0, self.selected_index - 10)
+            self._update_display()
+
+        @kb.add("pagedown")
+        def page_down(event):
+            """Move selection down by page."""
+            self.selected_index = min(len(self.filtered_models) - 1, self.selected_index + 10)
+            self._update_display()
+
+        @kb.add("enter")
+        def select_model(event):
+            """Select the current model."""
+            if 0 <= self.selected_index < len(self.filtered_models):
+                self.selected_model = self.filtered_models[self.selected_index]
+                event.app.exit(result=self.selected_model)
+
+        @kb.add("c-c", "escape", "q")
+        def cancel(event):
+            """Cancel selection."""
+            event.app.exit(result=None)
+
+        @kb.add("/")
+        def focus_search(event):
+            """Focus the search input."""
+            event.app.layout.focus(self.search_buffer)
+
+        @kb.add("tab")
+        def next_provider(event):
+            """Jump to next provider."""
+            if not self.filtered_models:
+                return
+
+            current_provider = self.filtered_models[self.selected_index].provider
+            for i in range(self.selected_index + 1, len(self.filtered_models)):
+                if self.filtered_models[i].provider != current_provider:
+                    self.selected_index = i
+                    self._update_display()
+                    break
+
+        @kb.add("s-tab")
+        def prev_provider(event):
+            """Jump to previous provider."""
+            if not self.filtered_models:
+                return
+
+            current_provider = self.filtered_models[self.selected_index].provider
+            for i in range(self.selected_index - 1, -1, -1):
+                if self.filtered_models[i].provider != current_provider:
+                    self.selected_index = i
+                    self._update_display()
+                    break
+
+        return kb
+
+    def _on_search_changed(self, buffer: Buffer) -> None:
+        """Handle search text changes."""
+        self.search_text = buffer.text
+        self._filter_models()
+        self._update_display()
+
+    def _filter_models(self) -> None:
+        """Filter models based on search text."""
+        if not self.search_text:
+            self.filtered_models = self.models.copy()
+        else:
+            # Search and sort by relevance
+            self.filtered_models = self.registry.search_models(self.search_text)
+
+        # Reset selection
+        self.selected_index = 0 if self.filtered_models else -1
+
+    def _get_model_lines(self) -> List[StyleAndTextTuples]:
+        """Get formatted lines for model display."""
+        lines = []
+
+        if not self.filtered_models:
+            lines.append([("class:muted", "No models found")])
+            return lines
+
+        # Group models by provider
+        current_provider = None
+        for i, model in enumerate(self.filtered_models):
+            # Add provider header if changed
+            if model.provider != current_provider:
+                if current_provider is not None:
+                    lines.append([])  # Empty line between providers
+
+                provider_info = self.registry.providers.get(model.provider)
+                provider_name = provider_info.name if provider_info else model.provider
+                lines.append([("class:provider", f"▼ {provider_name}")])
+                current_provider = model.provider
+
+            # Model line
+            is_selected = i == self.selected_index
+
+            # Build model display
+            parts = []
+
+            # Selection indicator
+            if is_selected:
+                parts.append(("class:selected", "→ "))
+            else:
+                parts.append(("", "  "))
+
+            # Model ID and name
+            parts.append(
+                ("class:model-id" if not is_selected else "class:selected-id", f"{model.id}")
+            )
+            parts.append(("class:muted", " - "))
+            parts.append(
+                ("class:model-name" if not is_selected else "class:selected-name", model.name)
+            )
+
+            # Cost and limits
+            details = []
+            if model.cost.input is not None:
+                details.append(f"${model.cost.input}/{model.cost.output}")
+            if model.limits.context:
+                details.append(f"{model.limits.context // 1000}k")
+
+            if details:
+                parts.append(("class:muted", f" ({', '.join(details)})"))
+
+            # Capabilities badges
+            badges = []
+            if model.capabilities.attachment:
+                badges.append("📎")
+            if model.capabilities.reasoning:
+                badges.append("🧠")
+            if model.capabilities.tool_call:
+                badges.append("🔧")
+
+            if badges:
+                parts.append(("class:badges", " " + "".join(badges)))
+
+            lines.append(parts)
+
+        return lines
+
+    def _get_details_panel(self) -> StyleAndTextTuples:
+        """Get the details panel content for selected model."""
+        if not self.filtered_models or self.selected_index < 0:
+            return [("", "Select a model to see details")]
+
+        model = self.filtered_models[self.selected_index]
+        lines = []
+
+        # Model name and ID
+        lines.append([("class:title", model.name)])
+        lines.append([("class:muted", f"{model.full_id}")])
+        lines.append([])
+
+        # Pricing
+        lines.append([("class:section", "Pricing:")])
+        if model.cost.input is not None:
+            lines.append([("", f"  Input: ${model.cost.input} per 1M tokens")])
+            lines.append([("", f"  Output: ${model.cost.output} per 1M tokens")])
+        else:
+            lines.append([("class:muted", "  Not available")])
+        lines.append([])
+
+        # Limits
+        lines.append([("class:section", "Limits:")])
+        if model.limits.context:
+            lines.append([("", f"  Context: {model.limits.context:,} tokens")])
+        if model.limits.output:
+            lines.append([("", f"  Output: {model.limits.output:,} tokens")])
+        if not model.limits.context and not model.limits.output:
+            lines.append([("class:muted", "  Not specified")])
+        lines.append([])
+
+        # Capabilities
+        lines.append([("class:section", "Capabilities:")])
+        caps = []
+        if model.capabilities.attachment:
+            caps.append("Attachments")
+        if model.capabilities.reasoning:
+            caps.append("Reasoning")
+        if model.capabilities.tool_call:
+            caps.append("Tool calling")
+        if model.capabilities.temperature:
+            caps.append("Temperature control")
+
+        if caps:
+            for cap in caps:
+                lines.append([("", f"  ✓ {cap}")])
+        else:
+            lines.append([("class:muted", "  Basic text generation")])
+
+        if model.capabilities.knowledge:
+            lines.append([])
+            lines.append([("class:section", "Knowledge cutoff:")])
+            lines.append([("", f"  {model.capabilities.knowledge}")])
+
+        # Modalities
+        if model.modalities:
+            lines.append([])
+            lines.append([("class:section", "Modalities:")])
+            if "input" in model.modalities:
+                lines.append([("", f"  Input: {', '.join(model.modalities['input'])}")])
+            if "output" in model.modalities:
+                lines.append([("", f"  Output: {', '.join(model.modalities['output'])}")])
+
+        return lines
+
+    def _update_display(self) -> None:
+        """Update the display (called on changes)."""
+        # This will trigger a redraw through prompt_toolkit's event system
+        if hasattr(self, "app"):
+            self.app.invalidate()
+
+    def _create_layout(self) -> Layout:
+        """Create the application layout."""
+        # Model list
+        model_list = FormattedTextControl(self._get_model_lines, focusable=False, show_cursor=False)
+
+        model_window = Window(
+            content=model_list,
+            width=Dimension(min=40, preferred=60),
+            height=Dimension(min=10, preferred=20),
+            scroll_offsets=True,
+            wrap_lines=False,
+        )
+
+        # Details panel
+        details_control = FormattedTextControl(
+            self._get_details_panel, focusable=False, show_cursor=False
+        )
+
+        details_window = Window(
+            content=details_control, width=Dimension(min=30, preferred=40), wrap_lines=True
+        )
+
+        # Search bar
+        search_field = Window(
+            BufferControl(buffer=self.search_buffer, focus_on_click=True), height=1
+        )
+
+        search_label = Window(
+            FormattedTextControl(HTML("<b>Search:</b> ")), width=8, height=1, dont_extend_width=True
+        )
+
+        search_bar = VSplit([search_label, search_field])
+
+        # Help text
+        help_text = Window(
+            FormattedTextControl(
+                HTML(
+                    "<muted>↑↓: Navigate | Enter: Select | /: Search | Tab: Next provider | Esc: Cancel</muted>"
+                )
+            ),
+            height=1,
+            align=WindowAlign.CENTER,
+        )
+
+        # Main content
+        content = VSplit(
+            [Frame(model_window, title="Select Model"), Frame(details_window, title="Details")]
+        )
+
+        # Root layout
+        root = HSplit(
+            [
+                search_bar,
+                Window(height=1),  # Spacer
+                content,
+                Window(height=1),  # Spacer
+                help_text,
+            ]
+        )
+
+        return Layout(root)
+
+    async def select_model(self, initial_query: str = "") -> Optional[ModelInfo]:
+        """Show the model selector and return selected model."""
+        # Load all models
+        self.models = list(self.registry.models.values())
+        self.search_buffer.text = initial_query
+
+        # Filter initially
+        self._filter_models()
+
+        # Create application
+        self.app = Application(
+            layout=self._create_layout(),
+            key_bindings=self.kb,
+            mouse_support=True,
+            full_screen=False,
+            style=self._get_style(),
+        )
+
+        # Run the selector
+        result = await self.app.run_async()
+        return result
+
+    def _get_style(self) -> Style:
+        """Get the style for the selector."""
+        return Style.from_dict(
+            {
+                "provider": "bold cyan",
+                "model-id": "white",
+                "model-name": "ansiwhite",
+                "selected": "reverse bold",
+                "selected-id": "reverse bold white",
+                "selected-name": "reverse bold ansiwhite",
+                "muted": "gray",
+                "badges": "yellow",
+                "title": "bold ansiwhite",
+                "section": "bold cyan",
+            }
+        )
+
+
+async def select_model_interactive(
+    registry: Optional[ModelsRegistry] = None, initial_query: str = ""
+) -> Optional[str]:
+    """Show interactive model selector and return selected model ID."""
+    if registry is None:
+        registry = ModelsRegistry()
+        await registry.load()
+
+    selector = ModelSelector(registry)
+    model = await selector.select_model(initial_query)
+
+    if model:
+        return model.full_id
+    return None