chat-console 0.2.99__py3-none-any.whl → 0.3.4__py3-none-any.whl

app/main.py

@@ -23,6 +23,8 @@ file_handler.setFormatter(logging.Formatter('%(asctime)s - %(name)s - %(levelnam
 debug_logger = logging.getLogger("chat-cli-debug")
 debug_logger.setLevel(logging.DEBUG)
 debug_logger.addHandler(file_handler)
+# Prevent propagation to the root logger (which would print to console)
+debug_logger.propagate = False
 
 # Add a convenience function to log to this file
 def debug_log(message):
@@ -642,16 +644,21 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
         await self.update_messages_ui()
 
         # If this is the first message and dynamic titles are enabled, generate one
-        if is_first_message and self.current_conversation and CONFIG.get("generate_dynamic_titles", True):
+        # Only attempt title generation if the message has sufficient content (at least 3 characters)
+        if is_first_message and self.current_conversation and CONFIG.get("generate_dynamic_titles", True) and len(content) >= 3:
             log("First message detected, generating title...")
-            debug_log("First message detected, attempting to generate conversation title")
-            title_generation_in_progress = True # Use a local flag
+            print(f"First message detected, generating conversation title for: {content[:30]}...")
+            debug_log(f"First message detected with length {len(content)}, generating conversation title")
+            
+            # Show loading indicator for title generation
             loading = self.query_one("#loading-indicator")
-            loading.remove_class("hidden") # Show loading for title gen
+            loading.remove_class("hidden")
+            loading.update("🔤 Generating title...")
 
             try:
                 # Get appropriate client
                 model = self.selected_model
+                print(f"Using model for title generation: {model}")
                 debug_log(f"Selected model for title generation: '{model}'")
                 
                 # Check if model is valid
@@ -662,24 +669,12 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                         model = "gpt-3.5-turbo"
                         debug_log("Falling back to OpenAI gpt-3.5-turbo for title generation")
                     elif ANTHROPIC_API_KEY:
-                        model = "claude-instant-1.2"
-                        debug_log("Falling back to Anthropic claude-instant-1.2 for title generation")
+                        model = "claude-3-haiku-20240307"  # Updated to newer Claude model
+                        debug_log("Falling back to Anthropic Claude 3 Haiku for title generation")
                     else:
-                        # Last resort - check for a common Ollama model
-                        try:
-                            from app.api.ollama import 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")
-                                model = models[0].get("id", "llama3")
-                            else:
-                                model = "llama3"  # Common default
-                            debug_log(f"Falling back to Ollama model: {model}")
-                        except Exception as ollama_err:
-                            debug_log(f"Error getting Ollama models: {str(ollama_err)}")
-                            model = "llama3"  # Final fallback
-                            debug_log("Final fallback to llama3")
+                        # Last resort - use a common Ollama model
+                        model = "llama3"  # Common default
+                        debug_log("Falling back to Ollama model: llama3")
 
                 debug_log(f"Getting client for model: {model}")
                 client = await BaseModelClient.get_client_for_model(model)
@@ -707,17 +702,19 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                         elif ANTHROPIC_API_KEY:
                             from app.api.anthropic import AnthropicClient
                             client = await AnthropicClient.create()
-                            model = "claude-instant-1.2"
+                            model = "claude-3-haiku-20240307"  # Updated to newer Claude model
                             debug_log("Falling back to Anthropic for title generation")
                         else:
                             raise Exception("No valid API clients available for title generation")
 
                 # Generate title
+                print(f"Calling generate_conversation_title with model: {model}")
                 log(f"Calling generate_conversation_title with model: {model}")
                 debug_log(f"Calling generate_conversation_title with model: {model}")
                 title = await generate_conversation_title(content, model, client)
                 debug_log(f"Generated title: {title}")
                 log(f"Generated title: {title}")
+                print(f"Generated title: {title}")
 
                 # Update conversation title in database
                 self.db.update_conversation(
@@ -743,11 +740,10 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
             except Exception as e:
                 debug_log(f"Failed to generate title: {str(e)}")
                 log.error(f"Failed to generate title: {str(e)}")
+                print(f"Failed to generate title: {str(e)}")
                 self.notify(f"Failed to generate title: {str(e)}", severity="warning")
             finally:
-                title_generation_in_progress = False
                 # Hide loading indicator *only if* AI response generation isn't about to start
-                # This check might be redundant if generate_response always shows it anyway
                 if not self.is_generating:
                      loading.add_class("hidden")
                      
@@ -907,13 +903,17 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
 
             # Start streaming response
             debug_log("Creating assistant message with 'Thinking...'")
+            print("Creating assistant message with 'Thinking...'")
             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)
+            
+            # Force a layout refresh and scroll to end
+            self.refresh(layout=True)
             messages_container.scroll_end(animate=False)
-
+            
             # Add small delay to show thinking state
             await asyncio.sleep(0.5)
 
@@ -940,48 +940,71 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                         # Update the message object with the full content
                         assistant_message.content = content
 
-                        # Update UI with the content - this no longer triggers refresh itself
+                        # Update UI with the content - the MessageDisplay will now handle its own refresh
+                        # This is a critical change that ensures content is immediately visible
                         await message_display.update_content(content)
-
-                        # 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
+                        
+                        # CRITICAL: Force immediate UI refresh after EVERY update 
+                        # This ensures we don't need a second Enter press to see content
+                        self.refresh(layout=True)
+                        
+                        # Always scroll after each update to ensure visibility
+                        messages_container.scroll_end(animate=False)
+                        
+                        # For longer responses, we can throttle the heavy refreshes
+                        # to reduce visual jitter, but still do light refreshes for every update
                         content_length = len(content)
                         
-                        # Define some key refresh points
+                        # Define key refresh points that require more thorough updates
                         new_paragraph = content.endswith("\n") and content.count("\n") > 0
-                        do_refresh = (
-                            content_length < 5 or  # Only first few tokens
-                            content_length % 64 == 0 or  # Very infrequent periodic updates
-                            new_paragraph  # Refresh on paragraph breaks
+                        code_block = "```" in content
+                        needs_thorough_refresh = (
+                            content_length < 30 or       # Very aggressive for short responses
+                            content_length % 16 == 0 or  # More frequent periodic updates 
+                            new_paragraph or             # Refresh on paragraph breaks
+                            code_block                   # Refresh when code blocks are detected
                         )
                         
-                        # Check if it's been enough time since last refresh (250ms minimum)
+                        # Check if it's been enough time since last heavy refresh
+                        # Reduced from 200ms to 100ms for more responsive UI
                         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
+                        if needs_thorough_refresh and time_since_refresh > 0.1:
+                            # Store the time we did the heavy refresh
                             last_refresh_time = current_time
-                            # Skip layout updates completely during streaming
-                            # Just ensure content is still visible by scrolling
+                            
+                            # Ensure content is visible with an aggressive, guaranteed update sequence
+                            # 1. Scroll to ensure visibility
+                            messages_container.scroll_end(animate=False)
+                            
+                            # 2. Force a comprehensive refresh with layout recalculation
+                            self.refresh(layout=True)
+                            
+                            # 3. Small delay for rendering
+                            await asyncio.sleep(0.01)
+                            
+                            # 4. Another scroll to account for any layout changes
                             messages_container.scroll_end(animate=False)
+                            
                     except Exception as e:
                         debug_log(f"Error updating UI: {str(e)}")
                         log.error(f"Error updating UI: {str(e)}")
 
             # --- Remove the inner run_generation_worker function ---
 
-            # Start the worker directly using the imported function
-            debug_log("Starting generate_streaming_response worker")
-            # Call the @work decorated function directly
-            worker = generate_streaming_response(
-                self,
-                api_messages,
-                model,
-                style,
-                client,
-                update_ui # Pass the callback function
+            # Start the worker using Textual's run_worker to ensure state tracking
+            debug_log("Starting generate_streaming_response worker with run_worker")
+            worker = self.run_worker(
+                generate_streaming_response(
+                    self,
+                    api_messages,
+                    model,
+                    style,
+                    client,
+                    update_ui  # Pass the callback function
+                ),
+                name="generate_response"
             )
             self.current_generation_task = worker
             # Worker completion will be handled by on_worker_state_changed
@@ -1054,6 +1077,21 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                     # Update the final message object content (optional, UI should be up-to-date)
                     if self.messages and self.messages[-1].role == "assistant":
                         self.messages[-1].content = full_response
+                        
+                    # Force a UI refresh with the message display to ensure it's fully rendered
+                    try:
+                        # Get the message display for the assistant message
+                        messages_container = self.query_one("#messages-container")
+                        message_displays = messages_container.query("MessageDisplay")
+                        # Check if we found any message displays
+                        if message_displays and len(message_displays) > 0:
+                            # Get the last message display which should be our assistant message
+                            last_message_display = message_displays[-1]
+                            debug_log("Forcing final content update on message display")
+                            # Force a final content update
+                            await last_message_display.update_content(full_response)
+                    except Exception as disp_err:
+                        debug_log(f"Error updating final message display: {str(disp_err)}")
                 else:
                     debug_log("Worker finished successfully but response was empty or invalid.")
                     # Handle case where 'Thinking...' might still be the last message
@@ -1061,11 +1099,24 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                          self.messages.pop() # Remove 'Thinking...' if no content arrived
                          await self.update_messages_ui()
 
-                # Final UI refresh with minimal layout recalculation
-                # Use layout=False to prevent UI jumping at the end
-                self.refresh(layout=False)
-                await asyncio.sleep(0.1)  # Allow UI to stabilize
+                # Force a full UI refresh to ensure content is visible
                 messages_container = self.query_one("#messages-container")
+                
+                # Sequence of UI refreshes to ensure content is properly displayed
+                # 1. First do a lightweight refresh
+                self.refresh(layout=False)
+                
+                # 2. Short delay to allow the UI to process
+                await asyncio.sleep(0.1)  
+                
+                # 3. Ensure we're scrolled to the end
+                messages_container.scroll_end(animate=False)
+                
+                # 4. Full layout refresh
+                self.refresh(layout=True)
+                
+                # 5. Final delay and scroll to ensure everything is visible
+                await asyncio.sleep(0.1)
                 messages_container.scroll_end(animate=False)
 
         except Exception as e:

app/ui/chat_interface.py

@@ -132,17 +132,51 @@ class MessageDisplay(Static): # Inherit from Static instead of RichLog
         # This avoids text reflowing as new tokens arrive
         formatted_content = self._format_content(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)
+        # Use a direct update that forces refresh - critical fix for streaming
+        # This ensures content is immediately visible
+        self.update(formatted_content, refresh=True)
         
-        # No refresh or layout recalculation is performed here
-        # The parent container will handle refresh timing for better stability
+        # Force app-level refresh and scroll to ensure visibility
+        try:
+            # Always force app refresh for every update
+            if self.app:
+                # Force a full layout refresh to ensure content is visible
+                self.app.refresh(layout=True)
+                
+                # Find the messages container and scroll to end
+                containers = self.app.query("ScrollableContainer")
+                for container in containers:
+                    if hasattr(container, 'scroll_end'):
+                        container.scroll_end(animate=False)
+        except Exception as e:
+            # Log the error and fallback to local refresh
+            print(f"Error refreshing app: {str(e)}")
+            self.refresh(layout=True)
+            
+        # Small delay to allow UI to update
+        await asyncio.sleep(0.02)  # Increased delay for better rendering
         
     def _format_content(self, content: str) -> str:
-        """Format message content with timestamp"""
+        """Format message content with timestamp and handle markdown links"""
         timestamp = datetime.now().strftime("%H:%M")
-        return f"[dim]{timestamp}[/dim] {content}"
+        
+        # Fix markdown-style links that cause markup errors
+        # Convert [text](url) to a safe format for Textual markup
+        content = re.sub(
+            r'\[([^\]]+)\]\(([^)]+)\)',
+            lambda m: f"{m.group(1)} ({m.group(2)})",
+            content
+        )
+        
+        # Escape any other potential markup characters
+        content = content.replace("[", "\\[").replace("]", "\\]")
+        # But keep our timestamp markup
+        timestamp_markup = f"[dim]{timestamp}[/dim]"
+        
+        # Debug print to verify content is being formatted
+        print(f"Formatting content: {len(content)} chars")
+        
+        return f"{timestamp_markup} {content}"
 
 class InputWithFocus(Input):
     """Enhanced Input that better handles focus and maintains cursor position"""

app/ui/model_selector.py

@@ -162,14 +162,36 @@ class ModelSelector(Container):
         """Get model options for a specific provider"""
         logger = logging.getLogger(__name__)
         logger.info(f"Getting model options for provider: {provider}")
-        
+
+        options = []
+
+        if provider == "openai":
+            try:
+                from ..api.openai import OpenAIClient
+                client = await OpenAIClient.create()
+                models = await client.get_available_models()
+                logger.info(f"Found {len(models)} models from OpenAI API")
+                for model in models:
+                    options.append((model["name"], model["id"]))
+            except Exception as e:
+                logger.error(f"Error getting OpenAI models: {str(e)}")
+                # Fallback to static list
+                options = [
+                    ("gpt-3.5-turbo", "gpt-3.5-turbo"),
+                    ("gpt-4", "gpt-4"),
+                    ("gpt-4-turbo", "gpt-4-turbo"),
+                ]
+            # Do NOT add custom model option for OpenAI
+            return options
+
+        # Default: config-based models
         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:
@@ -214,7 +236,10 @@ class ModelSelector(Container):
                 ]
                 logger.info("Adding default Ollama models as fallback")
                 options.extend(default_models)
-                
+            options.append(("Custom Model...", "custom"))
+            return options
+
+        # For Anthropic and others, allow custom model
         options.append(("Custom Model...", "custom"))
         return options
         
@@ -243,12 +268,14 @@ class ModelSelector(Container):
                         
                     # Set the model if we found one
                     if first_model and len(first_model) >= 2:
-                        # Resolve the model ID before storing and sending
+                        # Get the original ID from the model option
                         original_id = first_model[1]
+                        # Resolve the model ID for internal use and messaging
                         resolved_id = resolve_model_id(original_id)
                         logger.info(f"on_select_changed (provider): Original ID '{original_id}' resolved to '{resolved_id}'")
                         self.selected_model = resolved_id
-                        model_select.value = resolved_id
+                        # Use the original ID for the select widget to avoid invalid value errors
+                        model_select.value = original_id
                         model_select.remove_class("hide")
                         self.query_one("#custom-model-input").add_class("hide")
                         self.post_message(self.ModelSelected(resolved_id))
@@ -310,24 +337,35 @@ class ModelSelector(Container):
     def set_selected_model(self, model_id: str) -> None:
         """Set the selected model, ensuring it's properly resolved"""
         # First resolve the model ID to ensure we're using the full ID
+        original_id = model_id
         resolved_id = resolve_model_id(model_id)
-        logger.info(f"set_selected_model: Original ID '{model_id}' resolved to '{resolved_id}'")
+        logger.info(f"set_selected_model: Original ID '{original_id}' resolved to '{resolved_id}'")
         
-        # Store the resolved ID
+        # Store the resolved ID internally
         self.selected_model = resolved_id
         
         # Update the UI based on whether this is a known model or custom
-        if resolved_id in CONFIG["available_models"]:
-            select = self.query_one("#model-select", Select)
+        # Check if the original ID is in the available options
+        model_select = self.query_one("#model-select", Select)
+        available_options = [opt[1] for opt in model_select.options]
+        
+        if original_id in available_options:
+            # Use the original ID for the select widget
             custom_input = self.query_one("#custom-model-input")
-            select.value = resolved_id
-            select.remove_class("hide")
+            model_select.value = original_id
+            model_select.remove_class("hide")
+            custom_input.add_class("hide")
+        elif resolved_id in available_options:
+            # If the resolved ID is in options, use that
+            custom_input = self.query_one("#custom-model-input")
+            model_select.value = resolved_id
+            model_select.remove_class("hide")
             custom_input.add_class("hide")
         else:
-            select = self.query_one("#model-select", Select)
+            # Use custom input for models not in the select options
             custom_input = self.query_one("#custom-model-input")
-            select.value = "custom"
-            select.add_class("hide")
+            model_select.value = "custom"
+            model_select.add_class("hide")
             custom_input.value = resolved_id
             custom_input.remove_class("hide")