chat-console 0.1.2__py3-none-any.whl → 0.1.5.dev1__py3-none-any.whl

app/api/anthropic.py

@@ -5,7 +5,7 @@ from ..config import ANTHROPIC_API_KEY
 
 class AnthropicClient(BaseModelClient):
     def __init__(self):
-        self.client = anthropic.Anthropic(api_key=ANTHROPIC_API_KEY)
+        self.client = anthropic.AsyncAnthropic(api_key=ANTHROPIC_API_KEY)
     
     def _prepare_messages(self, messages: List[Dict[str, str]], style: Optional[str] = None) -> List[Dict[str, str]]:
         """Prepare messages for Claude API"""
@@ -47,7 +47,7 @@ class AnthropicClient(BaseModelClient):
         
         return styles.get(style, "")
     
-    def generate_completion(self, messages: List[Dict[str, str]], 
+    async def generate_completion(self, messages: List[Dict[str, str]], 
                            model: str, 
                            style: Optional[str] = None, 
                            temperature: float = 0.7, 
@@ -55,7 +55,7 @@ class AnthropicClient(BaseModelClient):
         """Generate a text completion using Claude"""
         processed_messages = self._prepare_messages(messages, style)
         
-        response = self.client.messages.create(
+        response = await self.client.messages.create(
             model=model,
             messages=processed_messages,
             temperature=temperature,
@@ -72,7 +72,7 @@ class AnthropicClient(BaseModelClient):
         """Generate a streaming text completion using Claude"""
         processed_messages = self._prepare_messages(messages, style)
         
-        stream = self.client.messages.stream(
+        stream = await self.client.messages.stream(
             model=model,
             messages=processed_messages,
             temperature=temperature,

app/api/base.py

@@ -13,7 +13,6 @@ class BaseModelClient(ABC):
         """Generate a text completion"""
         pass
     
-    @abstractmethod
     @abstractmethod
     async def generate_stream(self, messages: List[Dict[str, str]], 
                             model: str, 
@@ -31,44 +30,55 @@ class BaseModelClient(ABC):
     @staticmethod
     def get_client_for_model(model_name: str) -> 'BaseModelClient':
         """Factory method to get appropriate client for model"""
-        from ..config import CONFIG
+        from ..config import CONFIG, AVAILABLE_PROVIDERS
         from .anthropic import AnthropicClient
         from .openai import OpenAIClient
+        from .ollama import OllamaClient
+        import logging
+        
+        logger = logging.getLogger(__name__)
         
-        # For known models, use their configured provider
+        # Get model info and provider
         model_info = CONFIG["available_models"].get(model_name)
+        model_name_lower = model_name.lower()
+        
+        # If model is in config, use its provider
         if model_info:
             provider = model_info["provider"]
+            if not AVAILABLE_PROVIDERS[provider]:
+                raise Exception(f"Provider '{provider}' is not available. Please check your configuration.")
+        # For custom models, try to infer provider
         else:
-            # For custom models, infer provider from name prefix
-            model_name_lower = model_name.lower()
-            if any(name in model_name_lower for name in ["gpt", "text-", "davinci"]):
+            # First try Ollama for known model names or if selected from Ollama UI
+            if (any(name in model_name_lower for name in ["llama", "mistral", "codellama", "gemma"]) or
+                model_name in [m["id"] for m in CONFIG.get("ollama_models", [])]):
+                if not AVAILABLE_PROVIDERS["ollama"]:
+                    raise Exception("Ollama server is not running. Please start Ollama and try again.")
+                provider = "ollama"
+                logger.info(f"Using Ollama for model: {model_name}")
+            # Then try other providers if they're available
+            elif any(name in model_name_lower for name in ["gpt", "text-", "davinci"]):
+                if not AVAILABLE_PROVIDERS["openai"]:
+                    raise Exception("OpenAI API key not found. Please set OPENAI_API_KEY environment variable.")
                 provider = "openai"
             elif any(name in model_name_lower for name in ["claude", "anthropic"]):
+                if not AVAILABLE_PROVIDERS["anthropic"]:
+                    raise Exception("Anthropic API key not found. Please set ANTHROPIC_API_KEY environment variable.")
                 provider = "anthropic"
-            elif any(name in model_name_lower for name in ["llama", "mistral", "codellama", "gemma"]):
-                provider = "ollama"
             else:
-                # Try to get from Ollama API first
-                from .ollama import OllamaClient
-                try:
-                    client = OllamaClient()
-                    models = client.get_available_models()
-                    if any(model["id"] == model_name for model in models):
-                        provider = "ollama"
-                    else:
-                        # Default to OpenAI if not found
-                        provider = "openai"
-                except:
-                    # Default to OpenAI if Ollama not available
-                    provider = "openai"
+                # Default to Ollama for unknown models
+                if AVAILABLE_PROVIDERS["ollama"]:
+                    provider = "ollama"
+                    logger.info(f"Defaulting to Ollama for unknown model: {model_name}")
+                else:
+                    raise Exception(f"Unknown model: {model_name}")
         
-        if provider == "anthropic":
-            return AnthropicClient()
+        # Return appropriate client
+        if provider == "ollama":
+            return OllamaClient()
         elif provider == "openai":
             return OpenAIClient()
-        elif provider == "ollama":
-            from .ollama import OllamaClient
-            return OllamaClient()
+        elif provider == "anthropic":
+            return AnthropicClient()
         else:
             raise ValueError(f"Unknown provider: {provider}")

app/api/ollama.py

@@ -1,34 +1,36 @@
 import aiohttp
+import asyncio
 import json
+import logging
 from typing import List, Dict, Any, Optional, Generator, AsyncGenerator
 from .base import BaseModelClient
-from ..config import CONFIG
+
+# Set up logging
+logger = logging.getLogger(__name__)
 
 class OllamaClient(BaseModelClient):
     def __init__(self):
-        self.base_url = "http://localhost:11434"
+        from ..config import OLLAMA_BASE_URL
+        from ..utils import ensure_ollama_running
+        self.base_url = OLLAMA_BASE_URL.rstrip('/')
+        logger.info(f"Initializing Ollama client with base URL: {self.base_url}")
+        
+        # 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.")
         
     def _prepare_messages(self, messages: List[Dict[str, str]], style: Optional[str] = None) -> str:
         """Convert chat messages to Ollama format"""
-        # Convert messages to a single string with role prefixes
+        # Start with any style instructions
         formatted_messages = []
-        
-        for msg in messages:
-            role = msg["role"]
-            content = msg["content"]
-            
-            if role == "system":
-                formatted_messages.append(f"System: {content}")
-            elif role == "user":
-                formatted_messages.append(f"Human: {content}")
-            elif role == "assistant":
-                formatted_messages.append(f"Assistant: {content}")
-                
-        # Add style instructions if provided
         if style and style != "default":
-            style_instructions = self._get_style_instructions(style)
-            formatted_messages.insert(0, f"System: {style_instructions}")
+            formatted_messages.append(self._get_style_instructions(style))
+            
+        # Add message content, preserving conversation flow
+        for msg in messages:
+            formatted_messages.append(msg["content"])
             
+        # Join with double newlines for better readability
         return "\n\n".join(formatted_messages)
     
     def _get_style_instructions(self, style: str) -> str:
@@ -42,75 +44,161 @@ class OllamaClient(BaseModelClient):
         
         return styles.get(style, "")
     
-    async def generate_completion(self, messages: List[Dict[str, str]], 
-                                model: str, 
-                                style: Optional[str] = None, 
-                                temperature: float = 0.7, 
+    async def get_available_models(self) -> List[Dict[str, Any]]:
+        """Get list of available Ollama models"""
+        logger.info("Fetching available Ollama models...")
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(
+                    f"{self.base_url}/api/tags",
+                    timeout=5,
+                    headers={"Accept": "application/json"}
+                ) as response:
+                    response.raise_for_status()
+                    data = await response.json()
+                    logger.debug(f"Ollama API response: {data}")
+                    
+                    if not isinstance(data, dict):
+                        logger.error("Invalid response format: expected object")
+                        raise Exception("Invalid response format: expected object")
+                    if "models" not in data:
+                        logger.error("Invalid response format: missing 'models' key")
+                        raise Exception("Invalid response format: missing 'models' key")
+                    if not isinstance(data["models"], list):
+                        logger.error("Invalid response format: 'models' is not an array")
+                        raise Exception("Invalid response format: 'models' is not an array")
+                    
+                    models = []
+                    for model in data["models"]:
+                        if not isinstance(model, dict) or "name" not in model:
+                            continue  # Skip invalid models
+                        models.append({
+                            "id": model["name"],
+                            "name": model["name"].title(),
+                            "tags": model.get("tags", [])
+                        })
+                    
+                    logger.info(f"Found {len(models)} Ollama models")
+                    return models
+                    
+        except aiohttp.ClientConnectorError:
+            error_msg = f"Could not connect to Ollama server at {self.base_url}. Please ensure Ollama is running and the URL is correct."
+            logger.error(error_msg)
+            raise Exception(error_msg)
+        except aiohttp.ClientTimeout:
+            error_msg = f"Connection to Ollama server at {self.base_url} timed out after 5 seconds. The server might be busy or unresponsive."
+            logger.error(error_msg)
+            raise Exception(error_msg)
+        except aiohttp.ClientError as e:
+            error_msg = f"Ollama API error: {str(e)}"
+            logger.error(error_msg)
+            raise Exception(error_msg)
+        except Exception as e:
+            error_msg = f"Unexpected error getting models: {str(e)}"
+            logger.error(error_msg)
+            raise Exception(error_msg)
+            
+    async def generate_completion(self, messages: List[Dict[str, str]],
+                                model: str,
+                                style: Optional[str] = None,
+                                temperature: float = 0.7,
                                 max_tokens: Optional[int] = None) -> str:
         """Generate a text completion using Ollama"""
+        logger.info(f"Generating completion with model: {model}")
         prompt = self._prepare_messages(messages, style)
+        retries = 2
+        last_error = None
         
-        async with aiohttp.ClientSession() as session:
-            async with session.post(
-                f"{self.base_url}/api/generate",
-                json={
-                    "model": model,
-                    "prompt": prompt,
-                    "temperature": temperature,
-                    "stream": False
-                }
-            ) as response:
-                response.raise_for_status()
-                data = await response.json()
-                return data["response"]
+        while retries >= 0:
+            try:
+                async with aiohttp.ClientSession() as session:
+                    logger.debug(f"Sending request to {self.base_url}/api/generate")
+                    async with session.post(
+                        f"{self.base_url}/api/generate",
+                        json={
+                            "model": model,
+                            "prompt": prompt,
+                            "temperature": temperature,
+                            "stream": False
+                        },
+                        timeout=30
+                    ) as response:
+                        response.raise_for_status()
+                        data = await response.json()
+                        if "response" not in data:
+                            raise Exception("Invalid response format from Ollama server")
+                        return data["response"]
+                        
+            except aiohttp.ClientConnectorError:
+                last_error = "Could not connect to Ollama server. Make sure Ollama is running and accessible at " + self.base_url
+            except aiohttp.ClientResponseError as e:
+                last_error = f"Ollama API error: {e.status} - {e.message}"
+            except aiohttp.ClientTimeout:
+                last_error = "Request to Ollama server timed out"
+            except json.JSONDecodeError:
+                last_error = "Invalid JSON response from Ollama server"
+            except Exception as e:
+                last_error = f"Error generating completion: {str(e)}"
+            
+            logger.error(f"Attempt failed: {last_error}")
+            retries -= 1
+            if retries >= 0:
+                logger.info(f"Retrying... {retries} attempts remaining")
+                await asyncio.sleep(1)
+                
+        raise Exception(last_error)
     
-    async def generate_stream(self, messages: List[Dict[str, str]], 
-                            model: str, 
+    async def generate_stream(self, messages: List[Dict[str, str]],
+                            model: str,
                             style: Optional[str] = None,
-                            temperature: float = 0.7, 
+                            temperature: float = 0.7,
                             max_tokens: Optional[int] = None) -> AsyncGenerator[str, None]:
         """Generate a streaming text completion using Ollama"""
+        logger.info(f"Starting streaming generation with model: {model}")
         prompt = self._prepare_messages(messages, style)
+        retries = 2
+        last_error = None
         
-        async with aiohttp.ClientSession() as session:
-            async with session.post(
-                f"{self.base_url}/api/generate",
-                json={
-                    "model": model,
-                    "prompt": prompt,
-                    "temperature": temperature,
-                    "stream": True
-                }
-            ) as response:
-                response.raise_for_status()
-                async for line in response.content:
-                    if line:
-                        chunk = line.decode().strip()
-                        try:
-                            data = json.loads(chunk)
-                            if "response" in data:
-                                yield data["response"]
-                        except json.JSONDecodeError:
-                            continue
-    
-    async def get_available_models(self) -> List[Dict[str, Any]]:
-        """Get list of available Ollama models"""
-        try:
-            async with aiohttp.ClientSession() as session:
-                async with session.get(f"{self.base_url}/api/tags") as response:
-                    response.raise_for_status()
-                    data = await response.json()
-                    models = data["models"]
-                    
-                    return [
-                        {"id": model["name"], "name": model["name"].title()}
-                        for model in models
-                    ]
-        except:
-            # Return some default models if Ollama is not running
-            return [
-                {"id": "llama2", "name": "Llama 2"},
-                {"id": "mistral", "name": "Mistral"},
-                {"id": "codellama", "name": "Code Llama"},
-                {"id": "gemma", "name": "Gemma"}
-            ]
+        while retries >= 0:
+            try:
+                async with aiohttp.ClientSession() as session:
+                    logger.debug(f"Sending streaming request to {self.base_url}/api/generate")
+                    async with session.post(
+                        f"{self.base_url}/api/generate",
+                        json={
+                            "model": model,
+                            "prompt": prompt,
+                            "temperature": temperature,
+                            "stream": True
+                        },
+                        timeout=30
+                    ) as response:
+                        response.raise_for_status()
+                        async for line in response.content:
+                            if line:
+                                chunk = line.decode().strip()
+                                try:
+                                    data = json.loads(chunk)
+                                    if "response" in data:
+                                        yield data["response"]
+                                except json.JSONDecodeError:
+                                    continue
+                        logger.info("Streaming completed successfully")
+                        return
+                        
+            except aiohttp.ClientConnectorError:
+                last_error = "Could not connect to Ollama server. Make sure Ollama is running and accessible at " + self.base_url
+            except aiohttp.ClientResponseError as e:
+                last_error = f"Ollama API error: {e.status} - {e.message}"
+            except aiohttp.ClientTimeout:
+                last_error = "Request to Ollama server timed out"
+            except Exception as e:
+                last_error = f"Error streaming completion: {str(e)}"
+            
+            logger.error(f"Streaming attempt failed: {last_error}")
+            retries -= 1
+            if retries >= 0:
+                logger.info(f"Retrying stream... {retries} attempts remaining")
+                await asyncio.sleep(1)
+                
+        raise Exception(last_error)

app/api/openai.py

@@ -57,17 +57,20 @@ class OpenAIClient(BaseModelClient):
         """Generate a streaming text completion using OpenAI"""
         processed_messages = self._prepare_messages(messages, style)
         
-        stream = await self.client.chat.completions.create(
-            model=model,
-            messages=processed_messages,
-            temperature=temperature,
-            max_tokens=max_tokens,
-            stream=True,
-        )
-        
-        async for chunk in stream:
-            if chunk.choices and chunk.choices[0].delta.content:
-                yield chunk.choices[0].delta.content
+        try:
+            stream = await self.client.chat.completions.create(
+                model=model,
+                messages=[{"role": m["role"], "content": m["content"]} for m in processed_messages],
+                temperature=temperature,
+                max_tokens=max_tokens,
+                stream=True,
+            )
+            
+            async for chunk in stream:
+                if chunk.choices and chunk.choices[0].delta.content is not None:
+                    yield chunk.choices[0].delta.content
+        except Exception as e:
+            raise Exception(f"OpenAI streaming error: {str(e)}")
     
     def get_available_models(self) -> List[Dict[str, Any]]:
         """Get list of available OpenAI models"""

app/config.py

@@ -12,14 +12,35 @@ APP_DIR.mkdir(exist_ok=True)
 DB_PATH = APP_DIR / "chat_history.db"
 CONFIG_PATH = APP_DIR / "config.json"
 
-# API Keys
+# API Keys and Provider Configuration
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
 ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY", "")
 OLLAMA_BASE_URL = os.getenv("OLLAMA_BASE_URL", "http://localhost:11434")
 
+def check_provider_availability():
+    """Check which providers are available"""
+    providers = {
+        "openai": bool(OPENAI_API_KEY),
+        "anthropic": bool(ANTHROPIC_API_KEY),
+        "ollama": False
+    }
+    
+    # Check if Ollama is running
+    import requests
+    try:
+        response = requests.get(OLLAMA_BASE_URL + "/api/tags", timeout=2)
+        providers["ollama"] = response.status_code == 200
+    except:
+        pass
+        
+    return providers
+
+# Get available providers
+AVAILABLE_PROVIDERS = check_provider_availability()
+
 # Default configuration
 DEFAULT_CONFIG = {
-    "default_model": "gpt-3.5-turbo",
+    "default_model": "mistral" if AVAILABLE_PROVIDERS["ollama"] else "gpt-3.5-turbo",
     "available_models": {
         "gpt-3.5-turbo": {
             "provider": "openai",
@@ -101,11 +122,26 @@ DEFAULT_CONFIG = {
     "auto_save": True
 }
 
+def validate_config(config):
+    """Validate and fix configuration issues"""
+    # Only validate non-Ollama providers since Ollama can be started on demand
+    default_model = config.get("default_model")
+    if default_model in config["available_models"]:
+        provider = config["available_models"][default_model]["provider"]
+        if provider != "ollama" and not AVAILABLE_PROVIDERS[provider]:
+            # Find first available model, preferring Ollama
+            for model, info in config["available_models"].items():
+                if info["provider"] == "ollama" or AVAILABLE_PROVIDERS[info["provider"]]:
+                    config["default_model"] = model
+                    break
+    return config
+
 def load_config():
     """Load the user configuration or create default if not exists"""
     if not CONFIG_PATH.exists():
-        save_config(DEFAULT_CONFIG)
-        return DEFAULT_CONFIG
+        validated_config = validate_config(DEFAULT_CONFIG.copy())
+        save_config(validated_config)
+        return validated_config
     
     try:
         with open(CONFIG_PATH, 'r') as f:
@@ -113,10 +149,14 @@ def load_config():
         # Merge with defaults to ensure all keys exist
         merged_config = DEFAULT_CONFIG.copy()
         merged_config.update(config)
-        return merged_config
+        # Validate and fix any issues
+        validated_config = validate_config(merged_config)
+        if validated_config != merged_config:
+            save_config(validated_config)
+        return validated_config
     except Exception as e:
         print(f"Error loading config: {e}. Using defaults.")
-        return DEFAULT_CONFIG
+        return validate_config(DEFAULT_CONFIG.copy())
 
 def save_config(config):
     """Save the configuration to disk"""

app/main.py

@@ -90,15 +90,21 @@ class SettingsScreen(Screen):
         self.app.pop_screen()
         
         # Only update settings if Done was pressed
-        if event.button.label == "Done" and self.app.current_conversation:
+        if event.button.label == "Done":
             try:
-                self.app.db.update_conversation(
-                    self.app.current_conversation.id,
-                    model=self.app.selected_model,
-                    style=self.app.selected_style
-                )
-                self.app.current_conversation.model = self.app.selected_model
-                self.app.current_conversation.style = self.app.selected_style
+                # Save settings globally
+                from app.utils import save_settings_to_config
+                save_settings_to_config(self.app.selected_model, self.app.selected_style)
+                
+                # Update current conversation if one exists
+                if self.app.current_conversation:
+                    self.app.db.update_conversation(
+                        self.app.current_conversation.id,
+                        model=self.app.selected_model,
+                        style=self.app.selected_style
+                    )
+                    self.app.current_conversation.model = self.app.selected_model
+                    self.app.current_conversation.style = self.app.selected_style
             except Exception as e:
                 self.app.notify(f"Error updating settings: {str(e)}", severity="error")
 
@@ -344,15 +350,20 @@ class SimpleChatApp(App):
         if not ANTHROPIC_API_KEY:
             api_issues.append("- ANTHROPIC_API_KEY is not set")
             
-        # Check Ollama availability
-        from app.api.ollama import OllamaClient
-        try:
-            ollama = OllamaClient()
-            models = await ollama.get_available_models()
-            if not models:
-                api_issues.append("- No Ollama models found")
-        except Exception:
-            api_issues.append("- Ollama server not running")
+        # Check Ollama availability and try to start if not running
+        from app.utils import ensure_ollama_running
+        if not ensure_ollama_running():
+            api_issues.append("- Ollama server not running and could not be started")
+        else:
+            # Check for available models
+            from app.api.ollama import OllamaClient
+            try:
+                ollama = OllamaClient()
+                models = await ollama.get_available_models()
+                if not models:
+                    api_issues.append("- No Ollama models found")
+            except Exception:
+                api_issues.append("- Error connecting to Ollama server")
         
         if api_issues:
             self.notify(
@@ -499,22 +510,30 @@ class SimpleChatApp(App):
                 return
                 
             # Start streaming response
-            assistant_message = Message(role="assistant", content="")
+            assistant_message = Message(role="assistant", content="Thinking...")
             self.messages.append(assistant_message)
             messages_container = self.query_one("#messages-container")
             message_display = MessageDisplay(assistant_message, highlight_code=CONFIG["highlight_code"])
             messages_container.mount(message_display)
             messages_container.scroll_end(animate=False)
             
+            # Add small delay to show thinking state
+            await asyncio.sleep(0.5)
+            
             # Stream chunks to the UI
-            async def update_ui(chunk: str):
+            async def update_ui(content: str):
                 if not self.is_generating:
                     return
                 
                 try:
-                    assistant_message.content += chunk
-                    # Update UI directly
-                    message_display.update_content(assistant_message.content)
+                    # Clear thinking indicator on first content
+                    if assistant_message.content == "Thinking...":
+                        assistant_message.content = ""
+                    
+                    # Update message with full content so far
+                    assistant_message.content = content
+                    # Update UI with full content
+                    message_display.update_content(content)
                     messages_container.scroll_end(animate=False)
                     # Let the event loop process the update
                     await asyncio.sleep(0)

app/ui/chat_interface.py

@@ -234,20 +234,30 @@ class ChatInterface(Container):
             
     async def add_message(self, role: str, content: str, update_last: bool = False) -> None:
         """Add or update a message in the chat"""
+        messages_container = self.query_one("#messages-container")
+        
         if update_last and self.current_message_display and role == "assistant":
             # Update existing message
             await self.current_message_display.update_content(content)
+            # Update message in history
+            if self.messages and self.messages[-1].role == "assistant":
+                self.messages[-1].content = content
         else:
             # Add new message
             message = Message(role=role, content=content)
             self.messages.append(message)
-            messages_container = self.query_one("#messages-container")
             self.current_message_display = MessageDisplay(
                 message, 
                 highlight_code=CONFIG["highlight_code"]
             )
             messages_container.mount(self.current_message_display)
             
+        # Save to conversation if exists
+        if self.conversation and self.conversation.id:
+            from ..database import ChatDatabase
+            db = ChatDatabase()
+            db.add_message(self.conversation.id, role, content)
+            
         self.scroll_to_bottom()
         
     async def send_message(self) -> None:

app/ui/model_selector.py

@@ -1,3 +1,4 @@
+import logging
 from typing import Dict, List, Any, Optional
 from textual.app import ComposeResult
 from textual.containers import Container
@@ -6,8 +7,12 @@ from textual.widget import Widget
 from textual.message import Message
 
 from ..config import CONFIG
+from ..api.ollama import OllamaClient
 from .chat_interface import ChatInterface
 
+# Set up logging
+logger = logging.getLogger(__name__)
+
 class ModelSelector(Container):
     """Widget for selecting the AI model to use"""
     
@@ -68,8 +73,8 @@ class ModelSelector(Container):
         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"
+            # Default to Ollama for unknown models since it's more flexible
+            self.selected_provider = "ollama"
         
     def compose(self) -> ComposeResult:
         """Set up the model selector"""
@@ -121,35 +126,79 @@ class ModelSelector(Container):
 
     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
+        # Always update model options to ensure we have the latest
+        model_select = self.query_one("#model-select", Select)
+        model_options = await self._get_model_options(self.selected_provider)
+        model_select.set_options(model_options)
+        
+        # Handle model selection
+        if self.selected_model in [opt[1] for opt in model_options]:
+            model_select.value = self.selected_model
+            model_select.remove_class("hide")
+            self.query_one("#custom-model-input").add_class("hide")
+        else:
+            model_select.value = "custom"
+            model_select.add_class("hide")
+            custom_input = self.query_one("#custom-model-input")
+            custom_input.value = self.selected_model
+            custom_input.remove_class("hide")
             
     async def _get_model_options(self, provider: str) -> List[tuple]:
         """Get model options for a specific provider"""
+        logger = logging.getLogger(__name__)
+        logger.info(f"Getting model options for provider: {provider}")
+        
         options = [
             (model_info["display_name"], model_id)
             for model_id, model_info in CONFIG["available_models"].items()
             if model_info["provider"] == provider
         ]
+        logger.info(f"Found {len(options)} models in config for {provider}")
         
         # Add available Ollama models
         if provider == "ollama":
             try:
-                from app.api.ollama import OllamaClient
+                logger.info("Initializing Ollama client...")
                 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
+                logger.info("Getting available Ollama models...")
+                try:
+                    models = await ollama.get_available_models()
+                    logger.info(f"Found {len(models)} models from Ollama API")
+                    
+                    # Store models in config for later use
+                    CONFIG["ollama_models"] = models
+                    from ..config import save_config
+                    save_config(CONFIG)
+                    logger.info("Saved Ollama models to config")
+                    
+                    for model in models:
+                        if model["id"] not in CONFIG["available_models"]:
+                            logger.info(f"Adding new Ollama model: {model['name']}")
+                            options.append((model["name"], model["id"]))
+                except AttributeError:
+                    # Fallback for sync method
+                    models = ollama.get_available_models()
+                    logger.info(f"Found {len(models)} models from Ollama API (sync)")
+                    CONFIG["ollama_models"] = models
+                    from ..config import save_config
+                    save_config(CONFIG)
+                    logger.info("Saved Ollama models to config (sync)")
+                    
+                    for model in models:
+                        if model["id"] not in CONFIG["available_models"]:
+                            logger.info(f"Adding new Ollama model: {model['name']}")
+                            options.append((model["name"], model["id"]))
+            except Exception as e:
+                logger.error(f"Error getting Ollama models: {str(e)}")
+                # Add default Ollama models if API fails
+                default_models = [
+                    ("Llama 2", "llama2"),
+                    ("Mistral", "mistral"),
+                    ("Code Llama", "codellama"),
+                    ("Gemma", "gemma")
+                ]
+                logger.info("Adding default Ollama models as fallback")
+                options.extend(default_models)
                 
         options.append(("Custom Model...", "custom"))
         return options
@@ -166,6 +215,8 @@ class ModelSelector(Container):
             if model_options:
                 self.selected_model = model_options[0][1]
                 model_select.value = self.selected_model
+                model_select.remove_class("hide")
+                self.query_one("#custom-model-input").add_class("hide")
                 self.post_message(self.ModelSelected(self.selected_model))
                 
         elif event.select.id == "model-select":
@@ -193,7 +244,6 @@ class ModelSelector(Container):
                 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

app/ui/styles.py

@@ -108,14 +108,19 @@ Screen {
 /* Action buttons */
 .action-button {
     background: $primary;
-    color: $text;
+    color: #FFFFFF !important; /* Explicit white text */
     border: none;
     min-width: 10;
     margin-left: 1;
+    padding: 0 1; /* Add padding */
+    text-style: bold;
+    font-size: 1.1;
 }
 
 .action-button:hover {
     background: $primary-lighten-1;
+    color: #FFFFFF !important;
+    text-style: bold;
 }
 
 /* Sidebar */

app/utils.py

@@ -1,202 +1,87 @@
-from datetime import datetime
-import re
-import asyncio
-import time
-from typing import List, Dict, Any, Optional, Generator, Awaitable, Callable
-import textwrap
-import threading
-from rich.text import Text
-from rich.markdown import Markdown
-from rich.syntax import Syntax
-from rich.panel import Panel
-from rich.console import Console
+import os
+import json
+import subprocess
+import logging
+from typing import Optional, Dict, Any, List
+from .config import CONFIG, save_config
 
-from .models import Message, Conversation
-from .database import ChatDatabase
-from .api.base import BaseModelClient
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-def generate_conversation_title(messages: List[Message], model: str) -> str:
-    """Generate a title for a conversation based on its content"""
-    # Find the first user message
-    first_user_message = None
-    for msg in messages:
-        if msg.role == "user":
-            first_user_message = msg
-            break
-            
-    if first_user_message is None:
-        return f"New conversation ({datetime.now().strftime('%Y-%m-%d %H:%M')})"
-    
-    # Use first line of the first user message (up to 40 chars)
-    content = first_user_message.content.strip()
-    
-    # Get first line
-    first_line = content.split('\n')[0]
-    
-    # Truncate if needed
-    if len(first_line) > 40:
-        title = first_line[:37] + "..."
-    else:
-        title = first_line
-        
-    return title
-
-def format_code_blocks(text: str) -> str:
-    """Ensure code blocks have proper formatting"""
-    # Make sure code blocks are properly formatted with triple backticks
-    pattern = r"```(\w*)\n(.*?)\n```"
-    
-    def code_replace(match):
-        lang = match.group(1)
-        code = match.group(2)
-        # Ensure code has proper indentation
-        code_lines = code.split('\n')
-        code = '\n'.join([line.rstrip() for line in code_lines])
-        return f"```{lang}\n{code}\n```"
-        
-    return re.sub(pattern, code_replace, text, flags=re.DOTALL)
-
-def extract_code_blocks(text: str) -> List[Dict[str, str]]:
-    """Extract code blocks from text content"""
-    blocks = []
-    pattern = r"```(\w*)\n(.*?)\n```"
-    matches = re.finditer(pattern, text, re.DOTALL)
-    
-    for match in matches:
-        lang = match.group(1) or "text"
-        code = match.group(2).strip()
-        blocks.append({
-            "language": lang,
-            "code": code,
-            "start": match.start(),
-            "end": match.end()
-        })
-    
-    return blocks
-
-def format_text(text: str, highlight_code: bool = True) -> Text:
-    """Format text with optional code highlighting"""
-    result = Text()
-    
-    if not highlight_code:
-        return Text(text)
-    
-    # Split by code blocks
-    parts = re.split(r'(```\w*\n.*?\n```)', text, flags=re.DOTALL)
-    
-    for part in parts:
-        if part.startswith('```'):
-            # Handle code block
-            match = re.match(r'```(\w*)\n(.*?)\n```', part, re.DOTALL)
-            if match:
-                lang = match.group(1) or "text"
-                code = match.group(2).strip()
-                syntax = Syntax(
-                    code,
-                    lang,
-                    theme="monokai",
-                    line_numbers=True,
-                    word_wrap=True,
-                    indent_guides=True
-                )
-                result.append("\n")
-                result.append(syntax)
-                result.append("\n")
-        else:
-            # Handle regular text
-            if part.strip():
-                result.append(Text(part.strip()))
-                result.append("\n")
-    
-    return result
-
-def create_new_conversation(db: ChatDatabase, model: str, style: str = "default") -> Conversation:
-    """Create a new conversation in the database"""
-    title = f"New conversation ({datetime.now().strftime('%Y-%m-%d %H:%M')})"
-    conversation_id = db.create_conversation(title, model, style)
-    
-    # Get full conversation object
-    conversation_data = db.get_conversation(conversation_id)
-    return Conversation.from_dict(conversation_data)
-
-def update_conversation_title(db: ChatDatabase, conversation: Conversation) -> None:
-    """Update the title of a conversation based on its content"""
-    if not conversation.messages:
-        return
-        
-    title = generate_conversation_title(conversation.messages, conversation.model)
-    db.update_conversation(conversation.id, title=title)
-    conversation.title = title
-
-def add_message_to_conversation(
-    db: ChatDatabase, 
-    conversation: Conversation, 
-    role: str, 
-    content: str
-) -> Message:
-    """Add a message to a conversation in the database"""
-    message_id = db.add_message(conversation.id, role, content)
-    
-    # Create message object
-    message = Message(
-        id=message_id,
-        conversation_id=conversation.id,
-        role=role,
-        content=content,
-        timestamp=datetime.now().isoformat()
-    )
-    
-    # Add to conversation
-    conversation.messages.append(message)
-    
-    # Update conversation title if it's the default
-    if conversation.title.startswith("New conversation"):
-        update_conversation_title(db, conversation)
-        
-    return message
-
-def run_in_thread(func: Callable, *args, **kwargs) -> threading.Thread:
-    """Run a function in a separate thread"""
-    thread = threading.Thread(target=func, args=args, kwargs=kwargs)
-    thread.daemon = True
-    thread.start()
-    return thread
-
-async def generate_streaming_response(
-    messages: List[Dict[str, str]],
-    model: str,
-    style: str,
-    client: BaseModelClient,
-    callback: Callable[[str], Awaitable[None]]
-) -> str:
-    """Generate a streaming response and call the callback for each chunk"""
+async def generate_streaming_response(messages: List[Dict], model: str, style: str, client: Any, callback: Any) -> str:
+    """Generate a streaming response from the model"""
+    logger.info(f"Starting streaming response with model: {model}")
     full_response = ""
-    
     try:
-        # Get the async generator from the client
-        stream = client.generate_stream(messages, model, style)
-        # Iterate over the generator properly
-        async for chunk in stream:
+        async for chunk in client.generate_stream(messages, model, style):
             if chunk:  # Only process non-empty chunks
                 full_response += chunk
-                # Update UI and ensure event loop processes it
-                await callback(chunk)
-                # Small delay to prevent overwhelming the event loop
-                await asyncio.sleep(0.01)
+                await callback(full_response)  # Send full response so far
+        logger.info("Streaming response completed")
+        return full_response
     except Exception as e:
-        error_msg = f"\n\nError generating response: {str(e)}"
-        full_response += error_msg
-        await callback(error_msg)
-        
-    return full_response
+        logger.error(f"Error in streaming response: {str(e)}")
+        raise
 
-def get_elapsed_time(start_time: float) -> str:
-    """Get the elapsed time as a formatted string"""
-    elapsed = time.time() - start_time
+def ensure_ollama_running() -> bool:
+    """
+    Check if Ollama is running and try to start it if not.
+    Returns True if Ollama is running after check/start attempt.
+    """
+    import requests
+    try:
+        logger.info("Checking if Ollama is running...")
+        response = requests.get("http://localhost:11434/api/tags", timeout=2)
+        if response.status_code == 200:
+            logger.info("Ollama is running")
+            return True
+        else:
+            logger.warning(f"Ollama returned status code: {response.status_code}")
+            return False
+    except requests.exceptions.ConnectionError:
+        logger.info("Ollama not running, attempting to start...")
+        try:
+            # Try to start Ollama
+            process = subprocess.Popen(
+                ["ollama", "serve"], 
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True
+            )
+            
+            # Wait a moment for it to start
+            import time
+            time.sleep(2)
+            
+            # Check if process is still running
+            if process.poll() is None:
+                logger.info("Ollama server started successfully")
+                # Check if we can connect
+                try:
+                    response = requests.get("http://localhost:11434/api/tags", timeout=2)
+                    if response.status_code == 200:
+                        logger.info("Successfully connected to Ollama")
+                        return True
+                    else:
+                        logger.error(f"Ollama returned status code: {response.status_code}")
+                except Exception as e:
+                    logger.error(f"Failed to connect to Ollama after starting: {str(e)}")
+            else:
+                stdout, stderr = process.communicate()
+                logger.error(f"Ollama failed to start. stdout: {stdout}, stderr: {stderr}")
+        except FileNotFoundError:
+            logger.error("Ollama command not found. Please ensure Ollama is installed.")
+        except Exception as e:
+            logger.error(f"Error starting Ollama: {str(e)}")
+    except Exception as e:
+        logger.error(f"Error checking Ollama status: {str(e)}")
     
-    if elapsed < 60:
-        return f"{elapsed:.1f}s"
-    else:
-        minutes = int(elapsed // 60)
-        seconds = elapsed % 60
-        return f"{minutes}m {seconds:.1f}s"
+    return False
+
+def save_settings_to_config(model: str, style: str) -> None:
+    """Save settings to global config file"""
+    logger.info(f"Saving settings to config - model: {model}, style: {style}")
+    CONFIG["default_model"] = model
+    CONFIG["default_style"] = style
+    save_config(CONFIG)

{chat_console-0.1.2.dist-info → chat_console-0.1.5.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: chat-console
-Version: 0.1.2
+Version: 0.1.5.dev1
 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.1.5.dev1.dist-info/RECORD

@@ -0,0 +1,23 @@
+app/__init__.py,sha256=u5X4kPcpqZ12ZLnhwwOCScNvftaknDTrb0DMXqR_iLc,130
+app/config.py,sha256=7C09kn2bmda9frTPfZ7f1JhagqHAZjGM5BYqZmhegYM,5190
+app/database.py,sha256=nt8CVuDpy6zw8mOYqDcfUmNw611t7Ln7pz22M0b6-MI,9967
+app/main.py,sha256=ZeLroiPrlGgXArL0Po545PB3SU6imkx2KATjld1hV6s,21996
+app/models.py,sha256=4-y9Lytay2exWPFi0FDlVeRL3K2-I7E-jBqNzTfokqY,2644
+app/utils.py,sha256=tbMhutE3vg9seGstD5k8MyUhJo5XbJ17p64dl2wTqYY,3481
+app/api/__init__.py,sha256=A8UL84ldYlv8l7O-yKzraVFcfww86SgWfpl4p7R03-w,62
+app/api/anthropic.py,sha256=x5PmBXEKe_ow2NWk8XdqSPR0hLOdCc_ypY5QAySeA78,4234
+app/api/base.py,sha256=-6RSxSpqe-OMwkaq1wVWbu3pVkte-ZYy8rmdvt-Qh48,3953
+app/api/ollama.py,sha256=2Yqyc6d3lwShAx4j1A97y7iPZWLeMw-wumtnhvQzAxY,9869
+app/api/openai.py,sha256=1fYgFXXL6yj_7lQ893Yj28RYG4M8d6gt_q1gzhhjcig,3641
+app/ui/__init__.py,sha256=RndfbQ1Tv47qdSiuQzvWP96lPS547SDaGE-BgOtiP_w,55
+app/ui/chat_interface.py,sha256=wFmCiSvwqp8Jia3nkMUxrYAou7Hr3UAqGhTvZoClVL8,11548
+app/ui/chat_list.py,sha256=WQTYVNSSXlx_gQal3YqILZZKL9UiTjmNMIDX2I9pAMM,11205
+app/ui/model_selector.py,sha256=xCuaohgYvebgP0Eel6-XzUn-7Y0SrJUArdTr-CDBZXc,12840
+app/ui/search.py,sha256=b-m14kG3ovqW1-i0qDQ8KnAqFJbi5b1FLM9dOnbTyIs,9763
+app/ui/styles.py,sha256=04AhPuLrOd2yenfRySFRestPeuTPeMLzhmMB67NdGvw,5615
+chat_console-0.1.5.dev1.dist-info/LICENSE,sha256=srHZ3fvcAuZY1LHxE7P6XWju2njRCHyK6h_ftEbzxSE,1057
+chat_console-0.1.5.dev1.dist-info/METADATA,sha256=XZ5qunyAZ9WupEaGJBg7DuUw2ZvkhXmAYn-q0xYM8ss,2904
+chat_console-0.1.5.dev1.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+chat_console-0.1.5.dev1.dist-info/entry_points.txt,sha256=kkVdEc22U9PAi2AeruoKklfkng_a_aHAP6VRVwrAD7c,67
+chat_console-0.1.5.dev1.dist-info/top_level.txt,sha256=io9g7LCbfmTG1SFKgEOGXmCFB9uMP2H5lerm0HiHWQE,4
+chat_console-0.1.5.dev1.dist-info/RECORD,,

chat_console-0.1.2.dist-info/RECORD

@@ -1,23 +0,0 @@
-app/__init__.py,sha256=u5X4kPcpqZ12ZLnhwwOCScNvftaknDTrb0DMXqR_iLc,130
-app/config.py,sha256=PLEic_jwfWvWJxDfQMbKSbJ4ULrcmDhVe0apqegMO_g,3571
-app/database.py,sha256=nt8CVuDpy6zw8mOYqDcfUmNw611t7Ln7pz22M0b6-MI,9967
-app/main.py,sha256=suyVFuVughSz4ld533sdwqtAedVN4EW1rZpoxNHksBY,21000
-app/models.py,sha256=4-y9Lytay2exWPFi0FDlVeRL3K2-I7E-jBqNzTfokqY,2644
-app/utils.py,sha256=oUpQpqrxvvQn0S0lMCSwDC1Rx0PHpoAIRDySohYV5Oo,6586
-app/api/__init__.py,sha256=A8UL84ldYlv8l7O-yKzraVFcfww86SgWfpl4p7R03-w,62
-app/api/anthropic.py,sha256=leWSnCfqKnxHB5k3l_oVty4km3q18dodJkPAxwvhEt0,4211
-app/api/base.py,sha256=-Lx6nfgvEPjrAnQXuCgG-zr8soD1AibTtP15gVD3O48,3138
-app/api/ollama.py,sha256=naD5-WVCthZ-0s4iBo_bYV1hRMcuczly-lghmB2_loQ,5033
-app/api/openai.py,sha256=70NITI4upGld_xpaCZLoMd0ObSeVdhtiyUfY9hYHlhE,3420
-app/ui/__init__.py,sha256=RndfbQ1Tv47qdSiuQzvWP96lPS547SDaGE-BgOtiP_w,55
-app/ui/chat_interface.py,sha256=5gSOa7zT9bWujkPYctB8gVm4yypnkmKHcY1VtaKcEQs,11126
-app/ui/chat_list.py,sha256=WQTYVNSSXlx_gQal3YqILZZKL9UiTjmNMIDX2I9pAMM,11205
-app/ui/model_selector.py,sha256=Rv0i2VjLL2-cp4Pn_uMnAnAIV7Zk9gBX1XoWKBzkxHg,10367
-app/ui/search.py,sha256=b-m14kG3ovqW1-i0qDQ8KnAqFJbi5b1FLM9dOnbTyIs,9763
-app/ui/styles.py,sha256=eVDBTpBGnQ-mg5SeLi6i74ZjhCpItxAwWh1IelD09GY,5445
-chat_console-0.1.2.dist-info/LICENSE,sha256=srHZ3fvcAuZY1LHxE7P6XWju2njRCHyK6h_ftEbzxSE,1057
-chat_console-0.1.2.dist-info/METADATA,sha256=4VoR4lrcZq-m37Kkpy4-Ld7QSKsUtqDwpvjj8xCW9WE,2899
-chat_console-0.1.2.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-chat_console-0.1.2.dist-info/entry_points.txt,sha256=kkVdEc22U9PAi2AeruoKklfkng_a_aHAP6VRVwrAD7c,67
-chat_console-0.1.2.dist-info/top_level.txt,sha256=io9g7LCbfmTG1SFKgEOGXmCFB9uMP2H5lerm0HiHWQE,4
-chat_console-0.1.2.dist-info/RECORD,,