chat-console 0.2.98__tar.gz → 0.2.99__tar.gz

{chat_console-0.2.98/chat_console.egg-info → chat_console-0.2.99}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chat-console
-Version: 0.2.98
+Version: 0.2.99
 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.98 → chat_console-0.2.99}/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.98"
+__version__ = "0.2.99"

{chat_console-0.2.98 → chat_console-0.2.99}/app/api/anthropic.py

@@ -7,7 +7,14 @@ from ..utils import resolve_model_id  # Import the resolve_model_id function
 
 class AnthropicClient(BaseModelClient):
     def __init__(self):
-        self.client = anthropic.AsyncAnthropic(api_key=ANTHROPIC_API_KEY)
+        self.client = None  # Initialize in create()
+
+    @classmethod
+    async def create(cls) -> 'AnthropicClient':
+        """Create a new instance with async initialization."""
+        instance = cls()
+        instance.client = anthropic.AsyncAnthropic(api_key=ANTHROPIC_API_KEY)
+        return instance
     
     def _prepare_messages(self, messages: List[Dict[str, str]], style: Optional[str] = None) -> List[Dict[str, str]]:
         """Prepare messages for Claude API"""

{chat_console-0.2.98 → chat_console-0.2.99}/app/api/base.py

@@ -71,7 +71,7 @@ class BaseModelClient(ABC):
             return None
             
     @staticmethod
-    def get_client_for_model(model_name: str) -> 'BaseModelClient':
+    async def get_client_for_model(model_name: str) -> 'BaseModelClient':
         """Factory method to get appropriate client for model"""
         from ..config import CONFIG, AVAILABLE_PROVIDERS
         from .anthropic import AnthropicClient
@@ -118,7 +118,7 @@ class BaseModelClient(ABC):
         
         # Return appropriate client
         if provider == "ollama":
-            return OllamaClient()
+            return await OllamaClient.create()
         elif provider == "openai":
             return OpenAIClient()
         elif provider == "anthropic":

{chat_console-0.2.98 → chat_console-0.2.99}/app/api/ollama.py

@@ -3,7 +3,6 @@ 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
@@ -15,7 +14,6 @@ logger = logging.getLogger(__name__)
 class OllamaClient(BaseModelClient):
     def __init__(self):
         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}")
         
@@ -27,10 +25,18 @@ class OllamaClient(BaseModelClient):
         
         # Path to the cached models file
         self.models_cache_path = Path(__file__).parent.parent / "data" / "ollama-models.json"
+
+    @classmethod
+    async def create(cls) -> 'OllamaClient':
+        """Factory method to create and initialize an OllamaClient instance"""
+        from ..utils import ensure_ollama_running
+        client = cls()
         
         # Try to start Ollama if not running
-        if not ensure_ollama_running():
+        if not await ensure_ollama_running():
             raise Exception(f"Failed to start Ollama server. Please ensure Ollama is installed and try again.")
+            
+        return client
         
     def _prepare_messages(self, messages: List[Dict[str, str]], style: Optional[str] = None) -> str:
         """Convert chat messages to Ollama format"""

{chat_console-0.2.98 → chat_console-0.2.99}/app/api/openai.py

@@ -5,7 +5,14 @@ from ..config import OPENAI_API_KEY
 
 class OpenAIClient(BaseModelClient):
     def __init__(self):
-        self.client = AsyncOpenAI(api_key=OPENAI_API_KEY)
+        self.client = None  # Initialize in create()
+
+    @classmethod
+    async def create(cls) -> 'OpenAIClient':
+        """Create a new instance with async initialization."""
+        instance = cls()
+        instance.client = AsyncOpenAI(api_key=OPENAI_API_KEY)
+        return instance
     
     def _prepare_messages(self, messages: List[Dict[str, str]], style: Optional[str] = None) -> List[Dict[str, str]]:
         """Prepare messages for OpenAI API"""

{chat_console-0.2.98 → chat_console-0.2.99}/app/main.py

@@ -6,6 +6,7 @@ import os
 import asyncio
 import typer
 import logging
+import time
 from typing import List, Optional, Callable, Awaitable
 from datetime import datetime
 
@@ -161,6 +162,15 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
     TITLE = "Chat Console"
     SUB_TITLE = "AI Chat Interface" # Keep SimpleChatApp SUB_TITLE
     DARK = True # Keep SimpleChatApp DARK
+    
+    # Add better terminal handling to fix UI glitches
+    SCREENS = {}
+    
+    # Force full screen mode and prevent background terminal showing through
+    FULL_SCREEN = True
+    
+    # Force capturing all mouse events for better stability
+    CAPTURE_MOUSE = True
 
     # Ensure the log directory exists in a standard cache location
     log_dir = os.path.expanduser("~/.cache/chat-cli")
@@ -424,7 +434,7 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
             # Check for available models # Keep SimpleChatApp on_mount
             from app.api.ollama import OllamaClient # Keep SimpleChatApp on_mount
             try: # Keep SimpleChatApp on_mount
-                ollama = OllamaClient() # Keep SimpleChatApp on_mount
+                ollama = await OllamaClient.create() # Keep SimpleChatApp on_mount
                 models = await ollama.get_available_models() # Keep SimpleChatApp on_mount
                 if not models: # Keep SimpleChatApp on_mount
                     api_issues.append("- No Ollama models found") # Keep SimpleChatApp on_mount
@@ -511,7 +521,7 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                 # Get the client for the current model first and cancel the connection
                 try:
                     model = self.selected_model
-                    client = BaseModelClient.get_client_for_model(model)
+                    client = await BaseModelClient.get_client_for_model(model)
                     
                     # Call the client's cancel method if it's supported
                     if hasattr(client, 'cancel_stream'):
@@ -581,19 +591,21 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
         messages_container = self.query_one("#messages-container") # Keep SimpleChatApp update_messages_ui
         messages_container.remove_children() # Keep SimpleChatApp update_messages_ui
 
-        # Batch add all messages first without scrolling or refreshing between each mount
-        # This avoids unnecessary layout shifts while adding messages
-        for message in self.messages: # Keep SimpleChatApp update_messages_ui
-            display = MessageDisplay(message, highlight_code=CONFIG["highlight_code"]) # Keep SimpleChatApp update_messages_ui
-            messages_container.mount(display) # Keep SimpleChatApp update_messages_ui
+        # Temporarily disable automatic refresh while mounting messages
+        # This avoids excessive layout calculations and reduces flickering
+        with self.batch_update():
+            # Batch add all messages first without any refresh/layout
+            for message in self.messages: # Keep SimpleChatApp update_messages_ui
+                display = MessageDisplay(message, highlight_code=CONFIG["highlight_code"]) # Keep SimpleChatApp update_messages_ui
+                messages_container.mount(display) # Keep SimpleChatApp update_messages_ui
+        
+        # A small delay after mounting all messages helps with layout stability
+        await asyncio.sleep(0.05)
         
-        # Perform a single refresh and scroll after mounting all messages
-        # This significantly reduces the visual bouncing effect
-        # A small delay before scrolling helps ensure stable layout
-        await asyncio.sleep(0.05)  # Single delay after all messages are mounted
+        # Scroll after all messages are added without animation
         messages_container.scroll_end(animate=False) # Keep SimpleChatApp update_messages_ui
         
-        # Use layout=False refresh if possible to further reduce bouncing
+        # Minimal refresh without full layout recalculation
         self.refresh(layout=False)
 
     async def on_input_submitted(self, event: Input.Submitted) -> None: # Keep SimpleChatApp on_input_submitted
@@ -656,7 +668,7 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                         # Last resort - check for a common Ollama model
                         try:
                             from app.api.ollama import OllamaClient
-                            ollama = OllamaClient()
+                            ollama = await OllamaClient.create()
                             models = await ollama.get_available_models()
                             if models and len(models) > 0:
                                 debug_log(f"Found {len(models)} Ollama models, using first one")
@@ -670,7 +682,7 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                             debug_log("Final fallback to llama3")
 
                 debug_log(f"Getting client for model: {model}")
-                client = BaseModelClient.get_client_for_model(model)
+                client = await BaseModelClient.get_client_for_model(model)
                 
                 if client is None:
                     debug_log(f"No client available for model: {model}, trying to initialize")
@@ -679,7 +691,7 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                     if client_type:
                         debug_log(f"Found client type {client_type.__name__} for {model}, initializing")
                         try:
-                            client = client_type()
+                            client = await client_type.create()
                             debug_log("Client initialized successfully")
                         except Exception as init_err:
                             debug_log(f"Error initializing client: {str(init_err)}")
@@ -689,12 +701,12 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                         # Try a different model as last resort
                         if OPENAI_API_KEY:
                             from app.api.openai import OpenAIClient
-                            client = OpenAIClient()
+                            client = await OpenAIClient.create()
                             model = "gpt-3.5-turbo"
                             debug_log("Falling back to OpenAI for title generation")
                         elif ANTHROPIC_API_KEY:
                             from app.api.anthropic import AnthropicClient
-                            client = AnthropicClient()
+                            client = await AnthropicClient.create()
                             model = "claude-instant-1.2"
                             debug_log("Falling back to Anthropic for title generation")
                         else:
@@ -811,7 +823,7 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                 else:
                     # Check for a common Ollama model
                     try:
-                        ollama = OllamaClient()
+                        ollama = await OllamaClient.create()
                         models = await ollama.get_available_models()
                         if models and len(models) > 0:
                             debug_log(f"Found {len(models)} Ollama models, using first one")
@@ -856,7 +868,7 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
             # Get appropriate client
             debug_log(f"Getting client for model: {model}")
             try:
-                client = BaseModelClient.get_client_for_model(model)
+                client = await BaseModelClient.get_client_for_model(model)
                 debug_log(f"Client: {client.__class__.__name__ if client else 'None'}")
                 
                 if client is None:
@@ -866,7 +878,7 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                     if client_type:
                         debug_log(f"Found client type {client_type.__name__} for {model}, initializing")
                         try:
-                            client = client_type()
+                            client = await client_type.create()
                             debug_log(f"Successfully initialized {client_type.__name__}")
                         except Exception as init_err:
                             debug_log(f"Error initializing client: {str(init_err)}")
@@ -876,12 +888,12 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                         # Try a different model as last resort
                         if OPENAI_API_KEY:
                             from app.api.openai import OpenAIClient
-                            client = OpenAIClient()
+                            client = await OpenAIClient.create()
                             model = "gpt-3.5-turbo"
                             debug_log("Falling back to OpenAI client")
                         elif ANTHROPIC_API_KEY:
                             from app.api.anthropic import AnthropicClient
-                            client = AnthropicClient()
+                            client = await AnthropicClient.create()
                             model = "claude-instant-1.2"
                             debug_log("Falling back to Anthropic client")
                         else:
@@ -907,6 +919,7 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
 
             # Stream chunks to the UI with synchronization
             update_lock = asyncio.Lock()
+            last_refresh_time = time.time()  # Initialize refresh throttling timer
 
             async def update_ui(content: str):
                 # This function remains the same, called by the worker
@@ -914,6 +927,9 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                     debug_log("update_ui called but is_generating is False, returning.")
                     return
 
+                # Make last_refresh_time accessible in inner scope
+                nonlocal last_refresh_time
+                
                 async with update_lock:
                     try:
                         # Clear thinking indicator on first content
@@ -927,20 +943,29 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                         # Update UI with the content - this no longer triggers refresh itself
                         await message_display.update_content(content)
 
-                        # Throttle UI updates to reduce visual jitter and improve performance
-                        # Only refresh visually every ~5 tokens (estimated by content length changes)
+                        # Much more aggressive throttling of UI updates to eliminate visual jitter
+                        # By using a larger modulo value, we significantly reduce refresh frequency
+                        # This improves stability at the cost of slightly choppier animations
                         content_length = len(content)
+                        
+                        # Define some key refresh points
+                        new_paragraph = content.endswith("\n") and content.count("\n") > 0
                         do_refresh = (
-                            content_length < 20 or  # Always refresh for the first few tokens
-                            content_length % 16 == 0 or  # Then periodically
-                            content.endswith("\n")  # And on newlines
+                            content_length < 5 or  # Only first few tokens
+                            content_length % 64 == 0 or  # Very infrequent periodic updates
+                            new_paragraph  # Refresh on paragraph breaks
                         )
                         
-                        if do_refresh:
-                            # Only scroll without full layout recalculation
+                        # Check if it's been enough time since last refresh (250ms minimum)
+                        current_time = time.time()
+                        time_since_refresh = current_time - last_refresh_time
+                        
+                        if do_refresh and time_since_refresh > 0.25:
+                            # Store the time we did the refresh
+                            last_refresh_time = current_time
+                            # Skip layout updates completely during streaming
+                            # Just ensure content is still visible by scrolling
                             messages_container.scroll_end(animate=False)
-                            # Light refresh without full layout recalculation
-                            self.refresh(layout=False)
                     except Exception as e:
                         debug_log(f"Error updating UI: {str(e)}")
                         log.error(f"Error updating UI: {str(e)}")

{chat_console-0.2.98 → chat_console-0.2.99}/app/ui/chat_interface.py

@@ -1,5 +1,4 @@
 from typing import List, Dict, Any, Optional, Callable, Awaitable
-import time
 import asyncio
 from datetime import datetime
 import re
@@ -66,9 +65,9 @@ class MessageDisplay(Static): # Inherit from Static instead of RichLog
         padding: 1;
         text-wrap: wrap; /* Explicitly enable text wrapping via CSS */
         content-align: left top; /* Anchor content to top-left */
-        overflow-y: visible; /* Allow content to expand */
+        overflow-y: auto; /* Changed from 'visible' to valid 'auto' value */
         box-sizing: border-box; /* Include padding in size calculations */
-        transitions: none; /* Disable any transitions that might cause animation */
+        transition: none; /* Fixed property name from 'transitions' to 'transition' */
     }
     
     MessageDisplay.user-message {
@@ -121,7 +120,11 @@ class MessageDisplay(Static): # Inherit from Static instead of RichLog
         self.update(self._format_content(self.message.content))
         
     async def update_content(self, content: str) -> None:
-        """Update the message content using Static.update()"""
+        """Update the message content using Static.update() with optimizations for streaming"""
+        # Quick unchanged content check to avoid unnecessary updates
+        if self.message.content == content:
+            return
+            
         # Update the stored message object content first
         self.message.content = content
         
@@ -129,11 +132,12 @@ class MessageDisplay(Static): # Inherit from Static instead of RichLog
         # This avoids text reflowing as new tokens arrive
         formatted_content = self._format_content(content)
         
-        # Update Static widget with minimal refresh
-        self.update(formatted_content)
+        # Use minimal update that doesn't trigger a refresh
+        # This allows parent to control refresh timing and avoid flickering
+        self.update(formatted_content, refresh=False)
         
-        # Important: Don't call refresh() here - let the parent handle timing
-        # This prevents constant layout recalculation on each token
+        # No refresh or layout recalculation is performed here
+        # The parent container will handle refresh timing for better stability
         
     def _format_content(self, content: str) -> str:
         """Format message content with timestamp"""
@@ -179,7 +183,7 @@ class ChatInterface(Container):
         padding: 0 1;
         content-align: left top; /* Keep content anchored at top */
         box-sizing: border-box;
-        scrollbar-size: 1 1; /* Smaller scrollbars for more stability */
+        scrollbar-gutter: stable; /* Better than scrollbar-size which isn't valid */
     }
     
     #input-area {

{chat_console-0.2.98 → chat_console-0.2.99}/app/utils.py

@@ -165,6 +165,9 @@ async def generate_streaming_response(
     
     debug_log(f"Messages validation complete: {len(messages)} total messages")
     
+    # Import time module within the worker function scope
+    import time
+    
     full_response = ""
     buffer = []
     last_update = time.time()
@@ -361,7 +364,7 @@ async def generate_streaming_response(
              return full_response
         return None # Indicate completion without full response (e.g., error before loop)
 
-def ensure_ollama_running() -> bool:
+async 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.
@@ -388,8 +391,7 @@ def ensure_ollama_running() -> bool:
             )
             
             # Wait a moment for it to start
-            import time
-            time.sleep(2)
+            await asyncio.sleep(2)  # Use asyncio.sleep instead of time.sleep
             
             # Check if process is still running
             if process.poll() is None:

{chat_console-0.2.98 → chat_console-0.2.99/chat_console.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chat-console
-Version: 0.2.98
+Version: 0.2.99
 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