chat-console 0.1.1__py3-none-any.whl

app/ui/model_selector.py

@@ -0,0 +1,296 @@
+from typing import Dict, List, Any, Optional
+from textual.app import ComposeResult
+from textual.containers import Container
+from textual.widgets import Select, Label, Input
+from textual.widget import Widget
+from textual.message import Message
+
+from ..config import CONFIG
+from .chat_interface import ChatInterface
+
+class ModelSelector(Container):
+    """Widget for selecting the AI model to use"""
+    
+    DEFAULT_CSS = """
+    ModelSelector {
+        width: 100%;
+        height: auto;
+        padding: 0;
+        background: $surface-darken-1;
+    }
+    
+    #selector-container {
+        width: 100%;
+        layout: horizontal;
+        height: 3;
+        padding: 0;
+    }
+    
+    #provider-select {
+        width: 30%;
+        height: 3;
+        margin-right: 1;
+    }
+    
+    #model-select, #custom-model-input {
+        width: 1fr;
+        height: 3;
+    }
+
+    #custom-model-input {
+        display: none;
+    }
+
+    #custom-model-input.show {
+        display: block;
+    }
+
+    #model-select.hide {
+        display: none;
+    }
+    """
+    
+    class ModelSelected(Message):
+        """Event sent when a model is selected"""
+        def __init__(self, model_id: str):
+            self.model_id = model_id
+            super().__init__()
+    
+    def __init__(
+        self, 
+        selected_model: str = None,
+        name: Optional[str] = None,
+        id: Optional[str] = None
+    ):
+        super().__init__(name=name, id=id)
+        self.selected_model = selected_model or CONFIG["default_model"]
+        # Handle custom models not in CONFIG
+        if self.selected_model in CONFIG["available_models"]:
+            self.selected_provider = CONFIG["available_models"][self.selected_model]["provider"]
+        else:
+            # Default to OpenAI for custom models
+            self.selected_provider = "openai"
+        
+    def compose(self) -> ComposeResult:
+        """Set up the model selector"""
+        with Container(id="selector-container"):
+            # Provider options including Ollama
+            provider_options = [
+                ("OpenAI", "openai"),
+                ("Anthropic", "anthropic"),
+                ("Ollama", "ollama")
+            ]
+            
+            # Provider selector
+            yield Select(
+                provider_options,
+                id="provider-select",
+                value=self.selected_provider,
+                allow_blank=False
+            )
+            
+            # Get initial model options synchronously
+            initial_options = []
+            for model_id, model_info in CONFIG["available_models"].items():
+                if model_info["provider"] == self.selected_provider:
+                    initial_options.append((model_info["display_name"], model_id))
+            
+            # Ensure we have at least the custom option
+            if not initial_options or self.selected_model not in [opt[1] for opt in initial_options]:
+                initial_options.append(("Custom Model...", "custom"))
+                is_custom = True
+                initial_value = "custom"
+            else:
+                is_custom = False
+                initial_value = self.selected_model
+            
+            # Model selector and custom input
+            yield Select(
+                initial_options,
+                id="model-select",
+                value=initial_value,
+                classes="hide" if is_custom else "",
+                allow_blank=False
+            )
+            yield Input(
+                value=self.selected_model if is_custom else "",
+                placeholder="Enter custom model name",
+                id="custom-model-input",
+                classes="" if is_custom else "hide"
+            )
+
+    async def on_mount(self) -> None:
+        """Initialize model options after mount"""
+        # Only update options if using Ollama provider since it needs async API call
+        if self.selected_provider == "ollama":
+            model_select = self.query_one("#model-select", Select)
+            model_options = await self._get_model_options(self.selected_provider)
+            model_select.set_options(model_options)
+            if not self.selected_model or self.selected_model not in CONFIG["available_models"]:
+                model_select.value = "custom"
+            else:
+                model_select.value = self.selected_model
+            
+    async def _get_model_options(self, provider: str) -> List[tuple]:
+        """Get model options for a specific provider"""
+        options = [
+            (model_info["display_name"], model_id)
+            for model_id, model_info in CONFIG["available_models"].items()
+            if model_info["provider"] == provider
+        ]
+        
+        # Add available Ollama models
+        if provider == "ollama":
+            try:
+                from app.api.ollama import OllamaClient
+                ollama = OllamaClient()
+                ollama_models = await ollama.get_available_models()
+                for model in ollama_models:
+                    if model["id"] not in CONFIG["available_models"]:
+                        options.append((model["name"], model["id"]))
+            except:
+                pass
+                
+        options.append(("Custom Model...", "custom"))
+        return options
+        
+    async def on_select_changed(self, event: Select.Changed) -> None:
+        """Handle select changes"""
+        if event.select.id == "provider-select":
+            self.selected_provider = event.value
+            # Update model options
+            model_select = self.query_one("#model-select", Select)
+            model_options = await self._get_model_options(self.selected_provider)
+            model_select.set_options(model_options)
+            # Select first model of new provider
+            if model_options:
+                self.selected_model = model_options[0][1]
+                model_select.value = self.selected_model
+                self.post_message(self.ModelSelected(self.selected_model))
+                
+        elif event.select.id == "model-select":
+            if event.value == "custom":
+                # Show custom input
+                model_select = self.query_one("#model-select")
+                custom_input = self.query_one("#custom-model-input")
+                model_select.add_class("hide")
+                custom_input.remove_class("hide")
+                custom_input.focus()
+            else:
+                # Hide custom input
+                model_select = self.query_one("#model-select")
+                custom_input = self.query_one("#custom-model-input")
+                model_select.remove_class("hide")
+                custom_input.add_class("hide")
+                self.selected_model = event.value
+                self.post_message(self.ModelSelected(event.value))
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        """Handle custom model input changes"""
+        if event.input.id == "custom-model-input":
+            value = event.value.strip()
+            if value:  # Only update if there's actual content
+                self.selected_model = value
+                self.post_message(self.ModelSelected(value))
+            
+            
+    def get_selected_model(self) -> str:
+        """Get the current selected model ID"""
+        return self.selected_model
+    
+    def set_selected_model(self, model_id: str) -> None:
+        """Set the selected model"""
+        self.selected_model = model_id
+        if model_id in CONFIG["available_models"]:
+            select = self.query_one("#model-select", Select)
+            custom_input = self.query_one("#custom-model-input")
+            select.value = model_id
+            select.remove_class("hide")
+            custom_input.add_class("hide")
+        else:
+            select = self.query_one("#model-select", Select)
+            custom_input = self.query_one("#custom-model-input")
+            select.value = "custom"
+            select.add_class("hide")
+            custom_input.value = model_id
+            custom_input.remove_class("hide")
+
+class StyleSelector(Container):
+    """Widget for selecting the AI response style"""
+    
+    DEFAULT_CSS = """
+    StyleSelector {
+        width: 100%;
+        height: auto;
+        padding: 0;
+        background: $surface-darken-1;
+    }
+    
+    #selector-container {
+        width: 100%;
+        layout: horizontal;
+        height: 3;
+        padding: 0;
+    }
+    
+    #style-label {
+        width: 30%;
+        height: 3;
+        content-align: left middle;
+        padding-right: 1;
+    }
+    
+    #style-select {
+        width: 1fr;
+        height: 3;
+    }
+    """
+    
+    class StyleSelected(Message):
+        """Event sent when a style is selected"""
+        def __init__(self, style_id: str):
+            self.style_id = style_id
+            super().__init__()
+    
+    def __init__(
+        self, 
+        selected_style: str = None,
+        name: Optional[str] = None,
+        id: Optional[str] = None
+    ):
+        super().__init__(name=name, id=id)
+        self.selected_style = selected_style or CONFIG["default_style"]
+        
+    def compose(self) -> ComposeResult:
+        """Set up the style selector"""
+        with Container(id="selector-container"):
+            yield Label("Style:", id="style-label")
+            
+            # Get style options
+            options = []
+            for style_id, style_info in CONFIG["user_styles"].items():
+                options.append((style_info["name"], style_id))
+                
+            yield Select(
+                options, 
+                id="style-select", 
+                value=self.selected_style, 
+                allow_blank=False
+            )
+        
+    def on_select_changed(self, event: Select.Changed) -> None:
+        """Handle select changes"""
+        if event.select.id == "style-select":
+            self.selected_style = event.value
+            self.post_message(self.StyleSelected(event.value))
+            
+    def get_selected_style(self) -> str:
+        """Get the current selected style ID"""
+        return self.selected_style
+    
+    def set_selected_style(self, style_id: str) -> None:
+        """Set the selected style"""
+        if style_id in CONFIG["user_styles"]:
+            self.selected_style = style_id
+            select = self.query_one("#style-select", Select)
+            select.value = style_id

app/ui/search.py

@@ -0,0 +1,308 @@
+from typing import List, Dict, Any, Optional, Callable
+import time
+
+from textual.app import ComposeResult
+from textual.containers import Container, ScrollableContainer
+from textual.reactive import reactive
+from textual.widgets import Button, Input, Label, Static
+from textual.widget import Widget
+from textual.message import Message
+from textual.timer import Timer
+
+from ..models import Conversation
+from ..database import ChatDatabase
+from ..config import CONFIG
+
+class SearchResult(Static):
+    """Widget to display a single search result"""
+    
+    DEFAULT_CSS = """
+    SearchResult {
+        width: 100%;
+        height: auto;
+        min-height: 3;
+        padding: 1;
+        border-bottom: solid $primary-darken-3;
+    }
+    
+    SearchResult:hover {
+        background: $primary-darken-2;
+    }
+    
+    .result-title {
+        width: 100%;
+        content-align: center middle;
+        text-align: left;
+        text-style: bold;
+    }
+    
+    .result-preview {
+        width: 100%;
+        color: $text-muted;
+        margin-top: 1;
+        text-align: left;
+    }
+    
+    .result-date {
+        width: 100%;
+        color: $text-muted;
+        text-align: right;
+        text-style: italic;
+    }
+    """
+    
+    class ResultSelected(Message):
+        """Event sent when a search result is selected"""
+        def __init__(self, conversation_id: int):
+            self.conversation_id = conversation_id
+            super().__init__()
+    
+    def __init__(
+        self, 
+        conversation: Conversation,
+        name: Optional[str] = None
+    ):
+        super().__init__(name=name)
+        self.conversation = conversation
+        
+    def compose(self) -> ComposeResult:
+        """Set up the search result"""
+        yield Label(self.conversation.title, classes="result-title")
+        
+        # Preview text (truncate if too long)
+        preview = getattr(self.conversation, 'preview', '')
+        if preview and len(preview) > 100:
+            preview = preview[:100] + "..."
+        
+        yield Label(preview, classes="result-preview")
+        
+        # Format date
+        updated_at = self.conversation.updated_at
+        if updated_at:
+            try:
+                from datetime import datetime
+                dt = datetime.fromisoformat(updated_at)
+                formatted_date = dt.strftime("%Y-%m-%d %H:%M")
+            except:
+                formatted_date = updated_at
+        else:
+            formatted_date = "Unknown"
+            
+        yield Label(formatted_date, classes="result-date")
+        
+    def on_click(self) -> None:
+        """Handle click events"""
+        self.post_message(self.ResultSelected(self.conversation.id))
+
+class SearchBar(Container):
+    """Widget for searching conversations"""
+    
+    DEFAULT_CSS = """
+    SearchBar {
+        width: 100%;
+        height: auto;
+        padding: 1;
+        background: $surface-darken-1;
+    }
+    
+    #search-input {
+        width: 100%;
+        height: 3;
+        margin-bottom: 1;
+    }
+    
+    #search-results-container {
+        width: 100%;
+        height: auto;
+        max-height: 15;
+        background: $surface;
+        display: none;
+    }
+    
+    #search-results-count {
+        width: 100%;
+        height: 2;
+        background: $primary-darken-1;
+        color: $text;
+        content-align: center middle;
+        text-align: center;
+    }
+    
+    #loading-indicator {
+        width: 100%;
+        height: 1;
+        background: $primary-darken-1;
+        color: $text;
+        display: none;
+    }
+    
+    #no-results {
+        width: 100%;
+        height: 3;
+        color: $text-muted;
+        content-align: center middle;
+        text-align: center;
+        display: none;
+    }
+    """
+    
+    is_searching = reactive(False)
+    search_results = reactive([])
+    search_timer: Optional[Timer] = None
+    
+    class SearchResultSelected(Message):
+        """Event sent when a search result is selected"""
+        def __init__(self, conversation_id: int):
+            self.conversation_id = conversation_id
+            super().__init__()
+    
+    def __init__(
+        self,
+        db: ChatDatabase,
+        name: Optional[str] = None,
+        id: Optional[str] = None
+    ):
+        super().__init__(name=name, id=id)
+        self.db = db
+        
+    def compose(self) -> ComposeResult:
+        """Set up the search bar"""
+        yield Input(placeholder="Search conversations...", id="search-input")
+        
+        with Container(id="loading-indicator"):
+            yield Label("Searching...", id="loading-text")
+            
+        with Container(id="search-results-container"):
+            yield Label("Search Results", id="search-results-count")
+            
+            with ScrollableContainer(id="results-scroll"):
+                yield Label("No results found.", id="no-results")
+        
+    def on_unmount(self) -> None:
+        """Clean up when unmounting"""
+        if self.search_timer:
+            self.search_timer.stop()
+            self.search_timer = None
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        """Handle input changes"""
+        if event.input.id == "search-input":
+            query = event.value.strip()
+            
+            # Cancel existing timer if any
+            if self.search_timer:
+                self.search_timer.stop()
+                self.search_timer = None
+                
+            if not query:
+                # Hide results when search is cleared
+                self.clear_results()
+                try:
+                    results_container = self.query_one("#search-results-container")
+                    if results_container:
+                        results_container.display = False
+                except Exception:
+                    pass
+                # Return focus to chat input
+                self._return_focus_to_chat()
+                return
+                
+            # Start a new timer (debounce)
+            try:
+                self.search_timer = self.set_timer(0.3, self.perform_search, query)
+            except Exception:
+                # If timer creation fails, perform search immediately
+                self.perform_search(query)
+                
+    def _return_focus_to_chat(self) -> None:
+        """Helper to return focus to chat input"""
+        try:
+            from .chat_interface import ChatInterface
+            chat_interface = self.app.query_one("#chat-interface", expect_type=ChatInterface)
+            if chat_interface:
+                input_field = chat_interface.query_one("#message-input")
+                if input_field:
+                    self.app.set_focus(input_field)
+        except Exception:
+            pass
+            
+    def perform_search(self, query: str) -> None:
+        """Perform the search after debounce"""
+        if not self.is_mounted:
+            return
+            
+        self.is_searching = True
+        
+        try:
+            search_results = self.db.search_conversations(query)
+            self.search_results = [Conversation.from_dict(c) for c in search_results]
+            
+            if self.is_mounted:  # Check if still mounted before updating UI
+                try:
+                    results_container = self.query_one("#search-results-container")
+                    if results_container:
+                        results_container.display = True
+                    self._update_results_ui()
+                except Exception:
+                    pass
+        except Exception:
+            # Handle search errors gracefully
+            self.search_results = []
+            if self.is_mounted:
+                try:
+                    self._update_results_ui()
+                except Exception:
+                    pass
+        finally:
+            self.is_searching = False
+            if self.search_timer:
+                self.search_timer.stop()
+                self.search_timer = None
+            
+    def _update_results_ui(self) -> None:
+        """Update the UI with current search results"""
+        results_count = self.query_one("#search-results-count")
+        results_count.update(f"Found {len(self.search_results)} results")
+        
+        scroll_container = self.query_one("#results-scroll")
+        
+        # Clear previous results
+        for child in scroll_container.children:
+            if not child.id == "no-results":
+                child.remove()
+                
+        no_results = self.query_one("#no-results")
+                
+        if not self.search_results:
+            no_results.display = True
+            return
+        else:
+            no_results.display = False
+            
+        # Mount results directly without using batch_update
+        for result in self.search_results:
+            scroll_container.mount(SearchResult(result))
+                
+    def on_search_result_result_selected(self, event: SearchResult.ResultSelected) -> None:
+        """Handle search result selection"""
+        self.post_message(self.SearchResultSelected(event.conversation_id))
+        
+        # Clear search and hide results
+        input_widget = self.query_one("#search-input", Input)
+        input_widget.value = ""
+        
+        results_container = self.query_one("#search-results-container")
+        results_container.display = False
+        
+        # Return focus to chat input
+        self._return_focus_to_chat()
+        
+    def clear_results(self) -> None:
+        """Clear search results"""
+        self.search_results = []
+        self._update_results_ui()
+        
+    def watch_is_searching(self, is_searching: bool) -> None:
+        """Watch the is_searching property"""
+        loading = self.query_one("#loading-indicator")
+        loading.display = True if is_searching else False