chat-console 0.2.3__tar.gz → 0.2.6__tar.gz

{chat_console-0.2.3 → chat_console-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chat-console
-Version: 0.2.3
+Version: 0.2.6
 Summary: A command-line interface for chatting with LLMs, storing chats and (future) rag interactions
 Home-page: https://github.com/wazacraftrfid/chat-console
 Author: Johnathan Greenaway

{chat_console-0.2.3 → chat_console-0.2.6}/app/__init__.py

@@ -3,4 +3,4 @@ Chat CLI
 A command-line interface for chatting with various LLM providers like ChatGPT and Claude.
 """
 
-__version__ = "0.2.3"
+__version__ = "0.2.6"

{chat_console-0.2.3 → chat_console-0.2.6}/app/api/ollama.py

@@ -2,6 +2,10 @@ import aiohttp
 import asyncio
 import json
 import logging
+import os
+import time
+from datetime import datetime, timedelta
+from pathlib import Path
 from typing import List, Dict, Any, Optional, Generator, AsyncGenerator
 from .base import BaseModelClient
 
@@ -18,6 +22,9 @@ class OllamaClient(BaseModelClient):
         # Track active stream session
         self._active_stream_session = None
         
+        # Path to the cached models file
+        self.models_cache_path = Path(__file__).parent.parent / "data" / "ollama-models.json"
+        
         # Try to start Ollama if not running
         if not ensure_ollama_running():
             raise Exception(f"Failed to start Ollama server. Please ensure Ollama is installed and try again.")
@@ -280,32 +287,59 @@ class OllamaClient(BaseModelClient):
                 "modified_at": None
             }
     
-    async def list_available_models_from_registry(self, query: str = "") -> List[Dict[str, Any]]:
-        """List available models from Ollama registry"""
-        logger.info("Fetching available models from Ollama registry")
+    async def _fetch_and_cache_models(self) -> List[Dict[str, Any]]:
+        """Fetch models from Ollama website and cache them for 24 hours"""
+        logger.info("Performing a full fetch of Ollama models to update cache")
+        
         try:
-            # First try to scrape the Ollama website for better model data
+            # First load models from base file
+            base_models = []
+            try:
+                # Read the base models file
+                base_file_path = Path(__file__).parent.parent / "data" / "ollama-models-base.json"
+                if base_file_path.exists():
+                    with open(base_file_path, 'r') as f:
+                        base_data = json.load(f)
+                        if "models" in base_data:
+                            base_models = base_data["models"]
+                            logger.info(f"Loaded {len(base_models)} models from base file")
+                            
+                            # Process models from the base file to ensure consistent format
+                            for model in base_models:
+                                # Convert any missing fields to expected format
+                                if "parameter_size" not in model and "variants" in model and model["variants"]:
+                                    # Use the first variant as the default parameter size if not specified
+                                    for variant in model["variants"]:
+                                        if any(char.isdigit() for char in variant):
+                                            # This looks like a size variant (e.g., "7b", "70b")
+                                            if variant.lower().endswith('b'):
+                                                model["parameter_size"] = variant.upper()
+                                            else:
+                                                model["parameter_size"] = f"{variant}B"
+                                            break
+                            
+            except Exception as e:
+                logger.warning(f"Error loading base models file: {str(e)}")
+            
+            # Web scraping for more models
+            scraped_models = []
             try:
                 async with aiohttp.ClientSession() as session:
-                    # Try to get model data from the Ollama website search page
+                    # Get model data from the Ollama website search page (without query to get all models)
                     search_url = "https://ollama.com/search"
-                    if query:
-                        search_url += f"?q={query}"
                     
-                    logger.info(f"Fetching models from Ollama web: {search_url}")
+                    logger.info(f"Fetching all models from Ollama web: {search_url}")
                     async with session.get(
                         search_url,
-                        timeout=10,
+                        timeout=20,  # Longer timeout for comprehensive scrape
                         headers={"User-Agent": "Mozilla/5.0 (compatible; chat-console/1.0)"}
                     ) as response:
                         if response.status == 200:
                             html = await response.text()
                             
                             # Extract model data from JSON embedded in the page
-                            # The data is in a script tag with JSON containing model information
                             try:
                                 import re
-                                import json
                                 
                                 # Look for model data in JSON format
                                 model_match = re.search(r'window\.__NEXT_DATA__\s*=\s*({.+?});', html, re.DOTALL)
@@ -321,7 +355,6 @@ class OllamaClient(BaseModelClient):
                                         logger.info(f"Found {len(web_models)} models on Ollama website")
                                         
                                         # Process models
-                                        processed_models = []
                                         for model in web_models:
                                             try:
                                                 # Skip models without necessary data
@@ -335,6 +368,10 @@ class OllamaClient(BaseModelClient):
                                                     "model_family": model.get('modelFamily', 'Unknown'),
                                                 }
                                                 
+                                                # Add variants if available
+                                                if model.get('variants'):
+                                                    processed_model["variants"] = model.get('variants', [])
+                                                
                                                 # Extract parameter size from model details
                                                 if model.get('parameterSize'):
                                                     processed_model["parameter_size"] = f"{model.get('parameterSize')}B"
@@ -390,6 +427,7 @@ class OllamaClient(BaseModelClient):
                                                             "phi": "3B",
                                                             "phi2": "3B",
                                                             "phi3": "3B",
+                                                            "phi4": "7B",
                                                             "orca-mini": "7B",
                                                             "llava": "7B",
                                                             "codellama": "7B",
@@ -423,6 +461,12 @@ class OllamaClient(BaseModelClient):
                                                                     first_variant = variants[0]
                                                                     if first_variant and 'parameterSize' in first_variant:
                                                                         param_size = f"{first_variant['parameterSize']}B"
+                                                                    # Just use the first variant if it looks like a size
+                                                                    elif isinstance(first_variant, str) and any(char.isdigit() for char in first_variant):
+                                                                        if first_variant.lower().endswith('b'):
+                                                                            param_size = first_variant.upper()
+                                                                        else:
+                                                                            param_size = f"{first_variant}B"
                                                             except Exception as e:
                                                                 logger.warning(f"Error getting parameter size from variants: {str(e)}")
                                                     
@@ -455,179 +499,166 @@ class OllamaClient(BaseModelClient):
                                                 else:
                                                     processed_model["size"] = 4500000000  # Default to ~4.5GB
                                                 
-                                                processed_models.append(processed_model)
+                                                scraped_models.append(processed_model)
                                             except Exception as e:
                                                 logger.warning(f"Error processing web model {model.get('name', 'unknown')}: {str(e)}")
-                                                
-                                        if processed_models:
-                                            logger.info(f"Successfully processed {len(processed_models)} models from Ollama website")
-                                            return processed_models
                             except Exception as e:
                                 logger.warning(f"Error extracting model data from Ollama website: {str(e)}")
             except Exception as web_e:
                 logger.warning(f"Error fetching from Ollama website: {str(web_e)}")
             
-            # Next try the library endpoint (newer Ollama versions)
+            # Add curated models from the registry
+            curated_models = await self.get_registry_models("")
+            
+            # Combine all models - prefer base models, then scraped models, then curated
+            all_models = []
+            existing_names = set()
+            
+            # First add all base models (highest priority)
+            for model in base_models:
+                if model.get("name"):
+                    all_models.append(model)
+                    existing_names.add(model["name"])
+            
+            # Then add scraped models if not already added
+            for model in scraped_models:
+                if model.get("name") and model["name"] not in existing_names:
+                    all_models.append(model)
+                    existing_names.add(model["name"])
+            
+            # Finally add curated models if not already added
+            for model in curated_models:
+                if model.get("name") and model["name"] not in existing_names:
+                    all_models.append(model)
+                    existing_names.add(model["name"])
+            
+            # Cache the combined models
+            cache_data = {
+                "last_updated": datetime.now().isoformat(),
+                "models": all_models
+            }
+            
             try:
-                async with aiohttp.ClientSession() as session:
-                    url = f"{self.base_url}/api/library"
-                    if query:
-                        url += f"?query={query}"
-                    async with session.get(
-                        url,
-                        timeout=10
-                    ) as response:
-                        if response.status == 200:
-                            data = await response.json()
-                            logger.debug(f"Ollama library response: {data}")
-                            if "models" in data:
-                                # If this succeeded, we'll use registry models instead of the curated list
-                                # Ensure models have all the needed fields
-                                registry_models = data.get("models", [])
-                                
-                                # Create a new list to store processed models
-                                processed_models = []
-                                
-                                for model in registry_models:
-                                    if "name" not in model:
-                                        continue
-                                    
-                                    # Process the model
-                                    try:
-                                        # Add default values for missing fields to avoid UNKNOWN displays
-                                        if "model_family" not in model:
-                                            try:
-                                                # Try to infer family from name
-                                                name = str(model["name"]).lower() if isinstance(model["name"], (str, int, float)) else ""
-                                                if "llama" in name:
-                                                    model["model_family"] = "Llama"
-                                                elif "mistral" in name:
-                                                    model["model_family"] = "Mistral"
-                                                elif "phi" in name:
-                                                    model["model_family"] = "Phi"
-                                                elif "gemma" in name:
-                                                    model["model_family"] = "Gemma"
-                                                else:
-                                                    model["model_family"] = "General"
-                                            except (KeyError, TypeError, ValueError) as e:
-                                                logger.warning(f"Error inferring model family: {str(e)}")
-                                                model["model_family"] = "General"
-                                        
-                                        try:
-                                            if "description" not in model or not model["description"]:
-                                                model_name = str(model["name"]) if isinstance(model["name"], (str, int, float)) else "Unknown"
-                                                model["description"] = f"{model_name} model"
-                                        except (KeyError, TypeError, ValueError) as e:
-                                            logger.warning(f"Error setting model description: {str(e)}")
-                                            model["description"] = "Model description unavailable"
-                                            
-                                        # Ensure size is present and has a reasonable value
-                                        if "size" not in model or not model["size"] or model["size"] == 0:
-                                            # Set a reasonable default size based on model name
-                                            try:
-                                                name = str(model["name"]).lower() if isinstance(model["name"], (str, int, float)) else ""
-                                                if "70b" in name or "65b" in name:
-                                                    model["size"] = 40000000000  # 40GB for 70B models
-                                                elif "405b" in name or "400b" in name:
-                                                    model["size"] = 200000000000  # 200GB for 405B models
-                                                elif "34b" in name or "35b" in name:
-                                                    model["size"] = 20000000000  # 20GB for 34B models
-                                                elif "27b" in name or "28b" in name:
-                                                    model["size"] = 15000000000  # 15GB for 27B models
-                                                elif "13b" in name or "14b" in name:
-                                                    model["size"] = 8000000000   # 8GB for 13B models
-                                                elif "7b" in name or "8b" in name:
-                                                    model["size"] = 4500000000   # 4.5GB for 7-8B models
-                                                elif "6b" in name:
-                                                    model["size"] = 3500000000   # 3.5GB for 6B models
-                                                elif "3b" in name:
-                                                    model["size"] = 2000000000   # 2GB for 3B models
-                                                elif "1b" in name or "2b" in name:
-                                                    model["size"] = 1500000000   # 1.5GB for 1-2B models
-                                                else:
-                                                    model["size"] = 4500000000   # Default to 4.5GB if unknown
-                                            except (KeyError, TypeError, ValueError) as e:
-                                                logger.warning(f"Error setting model size: {str(e)}")
-                                                model["size"] = 4500000000  # Default fallback size
-                                        
-                                        # Add parameter_size field based on model name
-                                        if "parameter_size" not in model:
-                                            try:
-                                                name = str(model["name"]).lower() if isinstance(model["name"], (str, int, float)) else ""
-                                                if "70b" in name:
-                                                    model["parameter_size"] = "70B"
-                                                elif "405b" in name or "400b" in name:
-                                                    model["parameter_size"] = "405B"
-                                                elif "34b" in name or "35b" in name:
-                                                    model["parameter_size"] = "34B"
-                                                elif "27b" in name or "28b" in name:
-                                                    model["parameter_size"] = "27B"
-                                                elif "13b" in name or "14b" in name:
-                                                    model["parameter_size"] = "13B"
-                                                elif "8b" in name:
-                                                    model["parameter_size"] = "8B"
-                                                elif "7b" in name:
-                                                    model["parameter_size"] = "7B"
-                                                elif "6b" in name:
-                                                    model["parameter_size"] = "6B"
-                                                elif "3b" in name:
-                                                    model["parameter_size"] = "3B"
-                                                elif "2b" in name:
-                                                    model["parameter_size"] = "2B"
-                                                elif "1b" in name:
-                                                    model["parameter_size"] = "1B"
-                                                elif "mini" in name:
-                                                    model["parameter_size"] = "3B"
-                                                elif "small" in name:
-                                                    model["parameter_size"] = "7B"
-                                                elif "medium" in name:
-                                                    model["parameter_size"] = "13B"
-                                                elif "large" in name:
-                                                    model["parameter_size"] = "34B"
-                                                else:
-                                                    model["parameter_size"] = "Unknown"
-                                            except (KeyError, TypeError, ValueError) as e:
-                                                logger.warning(f"Error setting parameter size: {str(e)}")
-                                                model["parameter_size"] = "Unknown"
-                                            
-                                        # Add to processed models list
-                                        processed_models.append(model)
-                                    except Exception as e:
-                                        logger.warning(f"Error processing model {model.get('name', 'unknown')}: {str(e)}")
-                                    
-                                return processed_models
-            except Exception as lib_e:
-                logger.warning(f"Error using /api/library endpoint: {str(lib_e)}, falling back to /api/tags")
+                with open(self.models_cache_path, 'w') as f:
+                    json.dump(cache_data, f, indent=2)
+                logger.info(f"Cached {len(all_models)} models to {self.models_cache_path}")
+            except Exception as cache_error:
+                logger.error(f"Error caching models: {str(cache_error)}")
+            
+            return all_models
                 
-            # Fallback to tags endpoint (older Ollama versions)
-            async with aiohttp.ClientSession() as session:
-                url = f"{self.base_url}/api/tags"
-                if query:
-                    url += f"?query={query}"
-                async with session.get(
-                    url,
-                    timeout=10
-                ) as response:
-                    response.raise_for_status()
-                    data = await response.json()
-                    logger.debug(f"Ollama registry response: {data}")
+        except Exception as e:
+            logger.error(f"Error during model fetch and cache: {str(e)}")
+            # Return an empty list in case of catastrophic failure
+            return []
+            
+    async def list_available_models_from_registry(self, query: str = "") -> List[Dict[str, Any]]:
+        """List available models from Ollama registry with cache support"""
+        logger.info(f"Fetching available models from Ollama registry, query: '{query}'")
+        
+        # Check if we need to update the cache
+        need_cache_update = True
+        models_from_cache = []
+        
+        try:
+            # Try to read from cache first
+            if self.models_cache_path.exists():
+                try:
+                    with open(self.models_cache_path, 'r') as f:
+                        cache_data = json.load(f)
                     
-                    if "models" in data:
-                        # This is local models, not registry models
-                        # Return empty list since we can't get registry models
-                        logger.warning("Tags endpoint returned local models, not registry models")
-                        return []
+                    # Check if cache is still valid (less than 24 hours old)
+                    if cache_data.get("last_updated"):
+                        last_updated = datetime.fromisoformat(cache_data["last_updated"])
+                        # Cache valid if less than 24 hours old
+                        if datetime.now() - last_updated < timedelta(hours=24):
+                            need_cache_update = False
+                            models_from_cache = cache_data.get("models", [])
+                            logger.info(f"Using cached models from {last_updated.isoformat()} ({len(models_from_cache)} models)")
+                        else:
+                            logger.info(f"Cache from {last_updated.isoformat()} is older than 24 hours, refreshing")
+                except Exception as e:
+                    logger.warning(f"Error reading cache: {str(e)}, will refresh")
+            else:
+                logger.info("No cache found, creating a new one")
+        except Exception as e:
+            logger.warning(f"Error checking cache: {str(e)}")
+        
+        # Always read the base file first
+        base_models = []
+        try:
+            # Read the base models file
+            base_file_path = Path(__file__).parent.parent / "data" / "ollama-models-base.json"
+            if base_file_path.exists():
+                with open(base_file_path, 'r') as f:
+                    base_data = json.load(f)
+                    if "models" in base_data:
+                        base_models = base_data["models"]
+                        logger.info(f"Loaded {len(base_models)} models from base file")
+                        
+                # Process base models to ensure they have proper format
+                for model in base_models:
+                    # Make sure they have model_family
+                    if "model_family" not in model and "name" in model:
+                        name = model["name"].lower()
+                        if "llama" in name:
+                            model["model_family"] = "Llama"
+                        elif "mistral" in name:
+                            model["model_family"] = "Mistral"
+                        elif "phi" in name:
+                            model["model_family"] = "Phi"
+                        elif "gemma" in name:
+                            model["model_family"] = "Gemma"
+                        elif "qwen" in name:
+                            model["model_family"] = "Qwen"
+                        else:
+                            # Try to extract family from name (before any colon)
+                            base_name = name.split(":")[0]
+                            model["model_family"] = base_name.capitalize()
+                
+                # If no cache yet but base file exists, use base models and trigger update
+                if not models_from_cache and base_models:
+                    models_from_cache = base_models
+                    logger.info(f"Using {len(base_models)} models from base file while cache updates")
                     
-                    # Try to determine if we're dealing with an older version
-                    # Just return an empty list in this case
-                    return []
+                    # Start cache update in background
+                    asyncio.create_task(self._fetch_and_cache_models())
+                    need_cache_update = False
         except Exception as e:
-            logger.error(f"Error listing registry models: {str(e)}")
-            raise Exception(f"Failed to list models from registry: {str(e)}")
+            logger.warning(f"Error loading base models file: {str(e)}")
+        
+        # If we need to update the cache, do it now
+        if need_cache_update:
+            # Run the cache update in the background if we have cached data
+            if models_from_cache:
+                # We can use cached data for now but update in background
+                asyncio.create_task(self._fetch_and_cache_models())
+            else:
+                # We need to wait for the cache update
+                models_from_cache = await self._fetch_and_cache_models()
+        
+        # Always make sure base models are included
+        if base_models:
+            # Create a set of existing model names
+            existing_names = set(model.get("name", "") for model in models_from_cache)
+            
+            # Add base models if not already in cache
+            for model in base_models:
+                if model.get("name") and model["name"] not in existing_names:
+                    models_from_cache.append(model)
+                    existing_names.add(model["name"])
+            
+            logger.info(f"Combined total: {len(models_from_cache)} models")
+            
+        # Log the number of models available
+        logger.info(f"Total available models: {len(models_from_cache)}")
+        
+        # No filtering here - the UI will handle filtering
+        return models_from_cache
             
     async def get_registry_models(self, query: str = "") -> List[Dict[str, Any]]:
         """Get a curated list of popular Ollama models"""
-        logger.info("Returning a curated list of popular Ollama models")
+        logger.info("Returning a curated list of popular Ollama models (query: {})".format(query or "none"))
         
         # Provide a curated list of popular models as fallback
         models = [

{chat_console-0.2.3 → chat_console-0.2.6}/app/main.py

@@ -300,14 +300,13 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
 
     BINDINGS = [ # Keep SimpleChatApp BINDINGS, ensure Enter is not globally bound for settings
         Binding("q", "quit", "Quit", show=True, key_display="q"),
-        # Add priority=True to ensure these capture before input
-        Binding("n", "action_new_conversation", "New Chat", show=True, key_display="n", priority=True),
-        Binding("c", "action_new_conversation", "New Chat", show=False, key_display="c", priority=True), # Add priority to alias too
+        # Removed binding for "n" (new chat) since there's a dedicated button
+        Binding("c", "action_new_conversation", "New Chat", show=False, key_display="c", priority=True), # Keep alias with priority
         Binding("escape", "escape", "Cancel / Stop", show=True, key_display="esc"), # Escape might close settings panel too
         Binding("ctrl+c", "quit", "Quit", show=False),
         Binding("h", "view_history", "History", show=True, key_display="h", priority=True), # Add priority
         Binding("s", "settings", "Settings", show=True, key_display="s", priority=True),     # Add priority
-        Binding("t", "action_update_title", "Update Title", show=True, key_display="t", priority=True), # Add priority
+        # Removed binding for "t" (title update) since there's a dedicated button
         Binding("m", "model_browser", "Model Browser", show=True, key_display="m", priority=True), # Add model browser binding
     ] # Keep SimpleChatApp BINDINGS end
 

{chat_console-0.2.3 → chat_console-0.2.6}/app/ui/model_browser.py

@@ -1,3 +1,4 @@
+import asyncio
 import logging
 from typing import Dict, List, Any, Optional
 from textual.app import ComposeResult
@@ -253,11 +254,30 @@ class ModelBrowser(Container):
         available_table.add_columns("Model", "Size", "Family", "Description")
         available_table.cursor_type = "row"
         
+        # Show notification about model loading
+        self.notify("Initializing model browser, this might take a moment on first run...", 
+                   severity="information", timeout=5)
+        
         # Load models
         await self.load_local_models()
         
+        # Start loading available models in the background
+        asyncio.create_task(self.preload_available_models())
+        
         # Focus search input
         self.query_one("#model-search").focus()
+        
+    async def preload_available_models(self) -> None:
+        """Preload available models in the background"""
+        # Load the available models list in the background to make it faster when
+        # the user switches to the Available Models tab
+        try:
+            # This will trigger cache creation if needed, making tab switching faster
+            models = await self.ollama_client.list_available_models_from_registry()
+            if models:
+                logger.info(f"Preloaded {len(models)} available models")
+        except Exception as e:
+            logger.error(f"Error preloading available models: {str(e)}")
     
     async def load_local_models(self) -> None:
         """Load locally installed Ollama models"""
@@ -422,28 +442,58 @@ class ModelBrowser(Container):
             search_input = self.query_one("#model-search", Input)
             query = search_input.value.strip()
             
-            # Load models from registry
+            # Debug to track model loading
+            logger.info(f"Loading available models, query: '{query}'")
+            
+            # Load models from registry - don't apply the query here, get ALL models
             try:
                 # First try the API-based registry
-                self.available_models = await self.ollama_client.list_available_models_from_registry(query)
+                self.available_models = await self.ollama_client.list_available_models_from_registry("")
+                logger.info(f"Got {len(self.available_models)} models from registry")
+                
                 # If no models found, use the curated list
                 if not self.available_models:
-                    self.available_models = await self.ollama_client.get_registry_models()
+                    self.available_models = await self.ollama_client.get_registry_models("")
+                    logger.info(f"Got {len(self.available_models)} models from curated list")
             except Exception as e:
-                self.notify(f"Error from registry API: {str(e)}", severity="warning")
+                logger.error(f"Error from registry API: {str(e)}")
                 # Fallback to curated list
-                self.available_models = await self.ollama_client.get_registry_models()
+                self.available_models = await self.ollama_client.get_registry_models("")
+                logger.info(f"Fallback: Got {len(self.available_models)} models from curated list")
             
             # Clear and populate table
             available_table = self.query_one("#available-models-table", DataTable)
             available_table.clear()
             
-            # Get number of models loaded for debugging
+            # Get number of models loaded (but don't notify to avoid notification spam)
             model_count = len(self.available_models)
-            self.notify(f"Found {model_count} models to display", severity="information")
+            logger.info(f"Found {model_count} models to display")
+            
+            # Filter models by search query if provided
+            filtered_models = self.available_models
+            if query:
+                query = query.lower()
+                filtered_models = []
+                for model in self.available_models:
+                    # Check if query matches name, description or family
+                    name = str(model.get("name", "")).lower()
+                    desc = str(model.get("description", "")).lower()
+                    family = str(model.get("model_family", "")).lower()
+                    
+                    # Also check variants if available
+                    variants_match = False
+                    if "variants" in model and model["variants"]:
+                        variants_text = " ".join([str(v).lower() for v in model["variants"]])
+                        if query in variants_text:
+                            variants_match = True
+                    
+                    if query in name or query in desc or query in family or variants_match:
+                        filtered_models.append(model)
+                
+                logger.info(f"Filtered to {len(filtered_models)} models matching '{query}'")
             
-            # Add all models to the table - no pagination limit
-            for model in self.available_models:
+            # Add all filtered models to the table - no pagination limit
+            for model in filtered_models:
                 name = model.get("name", "Unknown")
                 
                 # Extract parameter size info (in billions)
@@ -455,6 +505,17 @@ class ModelBrowser(Container):
                     # Make sure it ends with B for billions if it doesn't already
                     if not size.upper().endswith("B"):
                         size += "B"
+                # Check if we can extract from variants
+                elif "variants" in model and model["variants"]:
+                    for variant in model["variants"]:
+                        if any(char.isdigit() for char in str(variant)):
+                            # This looks like a size variant (e.g., "7b", "70b")
+                            variant_str = str(variant).lower()
+                            if variant_str.endswith('b'):
+                                size = str(variant).upper()
+                            else:
+                                size = f"{variant}B"
+                            break
                 else:
                     # Extract from name if not available
                     model_name = str(name).lower()
@@ -504,6 +565,7 @@ class ModelBrowser(Container):
                             "phi": "3B",
                             "phi2": "3B",
                             "phi3": "3B",
+                            "phi4": "7B",
                             "orca-mini": "7B",
                             "llava": "7B",
                             "codellama": "7B",
@@ -526,12 +588,16 @@ class ModelBrowser(Container):
                 family = model.get("model_family", "Unknown")
                 description = model.get("description", "No description available")
                 
+                # Keep this for debugging
+                # logger.info(f"Adding model to table: {name} - {size} - {family}")
+                
                 available_table.add_row(name, size, family, description)
             
             actual_displayed = available_table.row_count
-            self.notify(f"Loaded {actual_displayed} available models", severity="information")
+            logger.info(f"Loaded {actual_displayed} available models")
             
         except Exception as e:
+            logger.error(f"Error loading available models: {str(e)}")
             self.notify(f"Error loading available models: {str(e)}", severity="error")
         finally:
             self.is_loading = False
@@ -745,218 +811,295 @@ class ModelBrowser(Container):
         model_id = self._get_selected_model_id()
         
         if not model_id:
-            self.notify("No model selected", severity="warning")
-            return
+            # Try to select the first model in the table
+            if self.current_tab == "local" and self.local_models:
+                model_id = self.local_models[0]["id"]
+            elif self.current_tab == "available" and self.available_models:
+                model_id = self.available_models[0]["name"]
+                
+            # If we still don't have a model ID, show warning and return
+            if not model_id:
+                self.notify("No model selected", severity="warning")
+                return
         
         # Get model details container
         details_container = self.query_one("#model-details")
         details_content = self.query_one("#details-content", Static)
         
-        try:
-            # Get model details from Ollama
-            details = await self.ollama_client.get_model_details(model_id)
-            
-            # Check for error in response
-            if "error" in details:
-                error_msg = f"Error: {details['error']}"
-                details_content.update(error_msg)
+        # Check if we're in "available" tab or "local" tab
+        if self.current_tab == "available":
+            # For available models, use cached info instead of making API calls
+            try:
+                # Find the model in our available_models list
+                model_info = None
+                for model in self.available_models:
+                    if model.get("name") == model_id:
+                        model_info = model
+                        break
+                
+                if not model_info:
+                    details_content.update(f"No details found for model: {model_id}")
+                    details_container.add_class("visible")
+                    return
+                
+                # Format the details from the cached info
+                formatted_details = f"Model: {model_id}\n"
+                
+                # Add parameters info
+                param_size = model_info.get("parameter_size", "Unknown")
+                if param_size and not str(param_size).upper().endswith("B"):
+                    param_size = f"{param_size}B"
+                formatted_details += f"Parameters: {param_size}\n"
+                
+                # Add family info
+                family = model_info.get("model_family", "Unknown")
+                formatted_details += f"Family: {family}\n"
+                
+                # Add description
+                description = model_info.get("description", "No description available.")
+                formatted_details += f"\nDescription:\n{description}\n"
+                
+                # Add variants if available
+                if "variants" in model_info and model_info["variants"]:
+                    formatted_details += f"\nVariants: {', '.join(model_info['variants'])}\n"
+                
+                # Add stats if available
+                if "stats" in model_info and model_info["stats"]:
+                    stats = model_info["stats"]
+                    formatted_details += f"\nStats:\n"
+                    if "pulls" in stats:
+                        formatted_details += f"Pulls: {stats['pulls']}\n"
+                    if "tags" in stats:
+                        formatted_details += f"Tags: {stats['tags']}\n"
+                    if "last_updated" in stats:
+                        formatted_details += f"Last Updated: {stats['last_updated']}\n"
+                
+                # Update and show details
+                details_content.update(formatted_details)
                 details_container.add_class("visible")
-                return
-            
-            formatted_details = f"Model: {model_id}\n"
-            
-            # Extract parameter size info
-            param_size = "Unknown"
-            
-            # First try to get parameter size from modelfile if available
-            if "modelfile" in details and details["modelfile"] is not None:
-                modelfile = details["modelfile"]
-                if "parameter_size" in modelfile and modelfile["parameter_size"]:
-                    param_size = str(modelfile["parameter_size"])
-                    # Make sure it ends with B for billions if it doesn't already
-                    if not param_size.upper().endswith("B"):
-                        param_size += "B"
-            
-            # If not found in modelfile, try to extract from name
-            if param_size == "Unknown":
-                model_name = str(model_id).lower()
-                if "70b" in model_name:
-                    param_size = "70B"
-                elif "405b" in model_name or "400b" in model_name:
-                    param_size = "405B"
-                elif "34b" in model_name or "35b" in model_name:
-                    param_size = "34B"
-                elif "27b" in model_name or "28b" in model_name:
-                    param_size = "27B"
-                elif "13b" in model_name or "14b" in model_name:
-                    param_size = "13B"
-                elif "8b" in model_name:
-                    param_size = "8B"
-                elif "7b" in model_name:
-                    param_size = "7B"
-                elif "6b" in model_name:
-                    param_size = "6B"
-                elif "3b" in model_name:
-                    param_size = "3B"
-                elif "2b" in model_name:
-                    param_size = "2B"
-                elif "1b" in model_name:
-                    param_size = "1B"
-                elif "mini" in model_name:
-                    param_size = "3B"
-                elif "small" in model_name:
-                    param_size = "7B"
-                elif "medium" in model_name:
-                    param_size = "13B"
-                elif "large" in model_name:
-                    param_size = "34B"
+            except Exception as e:
+                logger.error(f"Error showing available model details: {str(e)}")
+                details_content.update(f"Error loading details: {str(e)}")
+                details_container.add_class("visible")
+        else:
+            # For local models, we still need to get details from API
+            try:
+                # Get model details from Ollama
+                details = await self.ollama_client.get_model_details(model_id)
+                
+                # Check for error in response
+                if "error" in details:
+                    error_msg = f"Error: {details['error']}"
+                    details_content.update(error_msg)
+                    details_container.add_class("visible")
+                    return
                 
-                # Special handling for base models with no size indicator
+                formatted_details = f"Model: {model_id}\n"
+                
+                # Extract parameter size info
+                param_size = "Unknown"
+                
+                # First try to get parameter size from modelfile if available
+                if "modelfile" in details and details["modelfile"] is not None:
+                    modelfile = details["modelfile"]
+                    if "parameter_size" in modelfile and modelfile["parameter_size"]:
+                        param_size = str(modelfile["parameter_size"])
+                        # Make sure it ends with B for billions if it doesn't already
+                        if not param_size.upper().endswith("B"):
+                            param_size += "B"
+                
+                # If not found in modelfile, try to extract from name
                 if param_size == "Unknown":
-                    # Remove tag part if present to get base model
-                    base_name = model_name.split(":")[0]
+                    model_name = str(model_id).lower()
+                    if "70b" in model_name:
+                        param_size = "70B"
+                    elif "405b" in model_name or "400b" in model_name:
+                        param_size = "405B"
+                    elif "34b" in model_name or "35b" in model_name:
+                        param_size = "34B"
+                    elif "27b" in model_name or "28b" in model_name:
+                        param_size = "27B"
+                    elif "13b" in model_name or "14b" in model_name:
+                        param_size = "13B"
+                    elif "8b" in model_name:
+                        param_size = "8B"
+                    elif "7b" in model_name:
+                        param_size = "7B"
+                    elif "6b" in model_name:
+                        param_size = "6B"
+                    elif "3b" in model_name:
+                        param_size = "3B"
+                    elif "2b" in model_name:
+                        param_size = "2B"
+                    elif "1b" in model_name:
+                        param_size = "1B"
+                    elif "mini" in model_name:
+                        param_size = "3B"
+                    elif "small" in model_name:
+                        param_size = "7B"
+                    elif "medium" in model_name:
+                        param_size = "13B"
+                    elif "large" in model_name:
+                        param_size = "34B"
                     
-                    # Check if we have default parameter sizes for known models
-                    model_defaults = {
-                        "llama3": "8B",
-                        "llama2": "7B",
-                        "mistral": "7B",
-                        "gemma": "7B",
-                        "gemma2": "9B",
-                        "phi": "3B",
-                        "phi2": "3B",
-                        "phi3": "3B",
-                        "orca-mini": "7B",
-                        "llava": "7B",
-                        "codellama": "7B",
-                        "neural-chat": "7B",
-                        "wizard-math": "7B",
-                        "yi": "6B",
-                        "deepseek": "7B",
-                        "deepseek-coder": "7B",
-                        "qwen": "7B",
-                        "falcon": "7B",
-                        "stable-code": "3B"
-                    }
+                    # Special handling for base models with no size indicator
+                    if param_size == "Unknown":
+                        # Remove tag part if present to get base model
+                        base_name = model_name.split(":")[0]
+                        
+                        # Check if we have default parameter sizes for known models
+                        model_defaults = {
+                            "llama3": "8B",
+                            "llama2": "7B",
+                            "mistral": "7B",
+                            "gemma": "7B",
+                            "gemma2": "9B",
+                            "phi": "3B",
+                            "phi2": "3B",
+                            "phi3": "3B",
+                            "phi4": "7B",
+                            "orca-mini": "7B",
+                            "llava": "7B",
+                            "codellama": "7B",
+                            "neural-chat": "7B",
+                            "wizard-math": "7B",
+                            "yi": "6B",
+                            "deepseek": "7B",
+                            "deepseek-coder": "7B",
+                            "qwen": "7B",
+                            "falcon": "7B",
+                            "stable-code": "3B"
+                        }
+                        
+                        # Try to find a match in default sizes
+                        for model_name, default_size in model_defaults.items():
+                            if model_name in base_name:
+                                param_size = default_size
+                                break
                     
-                    # Try to find a match in default sizes
-                    for model_name, default_size in model_defaults.items():
-                        if model_name in base_name:
-                            param_size = default_size
-                            break
+                # Show both parameter size and disk size
+                formatted_details += f"Parameters: {param_size}\n"
+                formatted_details += f"Disk Size: {self._format_size(details.get('size', 0))}\n"
                 
-            # Show both parameter size and disk size
-            formatted_details += f"Parameters: {param_size}\n"
-            formatted_details += f"Disk Size: {self._format_size(details.get('size', 0))}\n"
-            
-            # Extract family info - check multiple possible locations
-            family = "Unknown"
-            template = "Unknown"
-            license_info = "Unknown"
-            system_prompt = ""
-            
-            if "modelfile" in details and details["modelfile"] is not None:
-                modelfile = details["modelfile"]
+                # Extract family info - check multiple possible locations
+                family = "Unknown"
+                template = "Unknown"
+                license_info = "Unknown"
+                system_prompt = ""
+                
+                if "modelfile" in details and details["modelfile"] is not None:
+                    modelfile = details["modelfile"]
 
-                # Ensure modelfile is a dictionary before accessing keys
-                if isinstance(modelfile, dict):
-                    # Extract family/parameter size
-                    if "parameter_size" in modelfile:
-                        family = modelfile.get("parameter_size")
-                    elif "family" in modelfile:
-                        family = modelfile.get("family")
-                    else:
-                        # Try to infer from model name if not explicitly set
-                        try:
-                            name = str(model_id).lower() if model_id is not None else ""
-                            if "llama" in name:
-                                family = "Llama"
-                            elif "mistral" in name:
-                                family = "Mistral"
-                            elif "phi" in name:
-                                family = "Phi"
-                            elif "gemma" in name:
-                                family = "Gemma"
-                            else:
+                    # Ensure modelfile is a dictionary before accessing keys
+                    if isinstance(modelfile, dict):
+                        # Extract family/parameter size
+                        if "parameter_size" in modelfile:
+                            family = modelfile.get("parameter_size")
+                        elif "family" in modelfile:
+                            family = modelfile.get("family")
+                        else:
+                            # Try to infer from model name if not explicitly set
+                            try:
+                                name = str(model_id).lower() if model_id is not None else ""
+                                if "llama" in name:
+                                    family = "Llama"
+                                elif "mistral" in name:
+                                    family = "Mistral"
+                                elif "phi" in name:
+                                    family = "Phi"
+                                elif "gemma" in name:
+                                    family = "Gemma"
+                                else:
+                                    family = "Unknown"
+                            except (TypeError, ValueError) as e:
+                                logger.error(f"Error inferring model family: {str(e)}")
                                 family = "Unknown"
-                        except (TypeError, ValueError) as e:
-                            logger.error(f"Error inferring model family: {str(e)}")
-                            family = "Unknown"
 
-                    # Get template
-                    template = modelfile.get("template", "Unknown")
+                        # Get template
+                        template = modelfile.get("template", "Unknown")
 
-                    # Get license
-                    license_info = modelfile.get("license", "Unknown")
+                        # Get license
+                        license_info = modelfile.get("license", "Unknown")
 
-                    # Get system prompt if available
-                    if "system" in modelfile:
-                        system_prompt = modelfile.get("system", "") # Use get for safety
-                else:
-                    # If modelfile is not a dict (e.g., a string), set defaults
-                    logger.warning(f"Modelfile for {model_id} is not a dictionary. Type: {type(modelfile)}")
-                    # Keep existing defaults or try to infer family from name again
-                    if family == "Unknown":
-                         try:
-                            name = str(model_id).lower() if model_id is not None else ""
-                            if "llama" in name: family = "Llama"
-                            elif "mistral" in name: family = "Mistral"
-                            elif "phi" in name: family = "Phi"
-                            elif "gemma" in name: family = "Gemma"
-                         except (TypeError, ValueError): pass # Ignore errors here
-                    # template, license_info, system_prompt remain "Unknown" or empty
-            
-            formatted_details += f"Family: {family}\n"
-            formatted_details += f"Template: {template}\n"
-            formatted_details += f"License: {license_info}\n"
-            
-            # Add timestamps if available
-            if "modified_at" in details and details["modified_at"]:
-                formatted_details += f"Modified: {details['modified_at']}\n"
-            elif "created_at" in details and details["created_at"]:
-                formatted_details += f"Created: {details['created_at']}\n"
+                        # Get system prompt if available
+                        if "system" in modelfile:
+                            system_prompt = modelfile.get("system", "") # Use get for safety
+                    else:
+                        # If modelfile is not a dict (e.g., a string), set defaults
+                        logger.warning(f"Modelfile for {model_id} is not a dictionary. Type: {type(modelfile)}")
+                        # Keep existing defaults or try to infer family from name again
+                        if family == "Unknown":
+                             try:
+                                name = str(model_id).lower() if model_id is not None else ""
+                                if "llama" in name: family = "Llama"
+                                elif "mistral" in name: family = "Mistral"
+                                elif "phi" in name: family = "Phi"
+                                elif "gemma" in name: family = "Gemma"
+                             except (TypeError, ValueError): pass # Ignore errors here
+                        # template, license_info, system_prompt remain "Unknown" or empty
                 
-            # Add system prompt if available
-            if system_prompt:
-                formatted_details += f"\nSystem Prompt:\n{system_prompt}\n"
-            
-            # Update and show details
-            details_content.update(formatted_details)
-            details_container.add_class("visible")
-            
-        except Exception as e:
-            self.notify(f"Error getting model details: {str(e)}", severity="error")
-            details_content.update(f"Error loading details: {str(e)}")
-            details_container.add_class("visible")
+                formatted_details += f"Family: {family}\n"
+                formatted_details += f"Template: {template}\n"
+                formatted_details += f"License: {license_info}\n"
+                
+                # Add timestamps if available
+                if "modified_at" in details and details["modified_at"]:
+                    formatted_details += f"Modified: {details['modified_at']}\n"
+                elif "created_at" in details and details["created_at"]:
+                    formatted_details += f"Created: {details['created_at']}\n"
+                    
+                # Add system prompt if available
+                if system_prompt:
+                    formatted_details += f"\nSystem Prompt:\n{system_prompt}\n"
+                
+                # Update and show details
+                details_content.update(formatted_details)
+                details_container.add_class("visible")
+                
+            except Exception as e:
+                self.notify(f"Error getting model details: {str(e)}", severity="error")
+                details_content.update(f"Error loading details: {str(e)}")
+                details_container.add_class("visible")
     
     def _get_selected_model_id(self) -> str:
         """Get the ID of the currently selected model"""
-        if self.current_tab == "local":
-            table = self.query_one("#local-models-table", DataTable)
-            if table.cursor_row is not None:
-                row = table.get_row_at(table.cursor_row)
-                # Get model ID from local models list
-                try:
-                    if row and len(row) > 0:
-                        row_name = str(row[0]) if row[0] is not None else ""
-                        for model in self.local_models:
-                            if model["name"] == row_name:
-                                return model["id"]
-                except (IndexError, TypeError) as e:
-                    logger.error(f"Error processing row data: {str(e)}")
-        else:
-            table = self.query_one("#available-models-table", DataTable)
-            if table.cursor_row is not None:
-                row = table.get_row_at(table.cursor_row)
-                # Return the model name as ID
-                try:
-                    if row and len(row) > 0:
-                        return str(row[0]) if row[0] is not None else ""
-                    else:
-                        return ""
-                except (IndexError, TypeError) as e:
-                    logger.error(f"Error getting model ID from row: {str(e)}")
-                    return ""
+        try:
+            if self.current_tab == "local":
+                table = self.query_one("#local-models-table", DataTable)
+                if table.cursor_row is not None:
+                    row = table.get_row_at(table.cursor_row)
+                    # Get model ID from local models list
+                    try:
+                        if row and len(row) > 0:
+                            row_name = str(row[0]) if row[0] is not None else ""
+                            for model in self.local_models:
+                                if model["name"] == row_name:
+                                    return model["id"]
+                    except (IndexError, TypeError) as e:
+                        logger.error(f"Error processing row data: {str(e)}")
+            else:
+                table = self.query_one("#available-models-table", DataTable)
+                if table.cursor_row is not None:
+                    try:
+                        row = table.get_row_at(table.cursor_row)
+                        # Return the model name as ID
+                        if row and len(row) > 0:
+                            return str(row[0]) if row[0] is not None else ""
+                    except Exception as e:
+                        logger.error(f"Error getting row at cursor: {str(e)}")
+                
+                # If we couldn't get a valid row, check if there are any rows and select the first one
+                if table.row_count > 0:
+                    try:
+                        # Select the first row and get its ID
+                        table.cursor_row = 0
+                        row = table.get_row_at(0)
+                        if row and len(row) > 0:
+                            return str(row[0]) if row[0] is not None else ""
+                    except Exception as e:
+                        logger.error(f"Error selecting first row: {str(e)}")
+        except Exception as e:
+            logger.error(f"Error in _get_selected_model_id: {str(e)}")
         
         return ""
     
@@ -995,3 +1138,9 @@ class ModelBrowser(Container):
                 self.app.call_later(self.load_local_models)
             else:
                 self.app.call_later(self.load_available_models)
+                
+    def on_input_changed(self, event: Input.Changed) -> None:
+        """Handle input changes for live search"""
+        if event.input.id == "model-search" and self.current_tab == "available":
+            # Auto-search as user types in the available models tab
+            self.app.call_later(self.load_available_models)

{chat_console-0.2.3 → chat_console-0.2.6}/chat_console.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chat-console
-Version: 0.2.3
+Version: 0.2.6
 Summary: A command-line interface for chatting with LLMs, storing chats and (future) rag interactions
 Home-page: https://github.com/wazacraftrfid/chat-console
 Author: Johnathan Greenaway