chat-console 0.1.95.dev1__tar.gz → 0.1.991.dev1__tar.gz

{chat_console-0.1.95.dev1 → chat_console-0.1.991.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chat-console
-Version: 0.1.95.dev1
+Version: 0.1.991.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.95.dev1 → chat_console-0.1.991.dev1}/app/config.py

@@ -119,7 +119,8 @@ DEFAULT_CONFIG = {
     "default_style": "default",
     "max_history_items": 100,
     "highlight_code": True,
-    "auto_save": True
+    "auto_save": True,
+    "generate_dynamic_titles": True
 }
 
 def validate_config(config):

{chat_console-0.1.95.dev1 → chat_console-0.1.991.dev1}/app/main.py

@@ -13,17 +13,18 @@ from textual.containers import Container, Horizontal, Vertical, ScrollableContai
 from textual.reactive import reactive
 from textual.widgets import Button, Input, Label, Static, Header, Footer, ListView, ListItem
 from textual.binding import Binding
-from textual import work
+from textual import work, log, on
 from textual.screen import Screen
 from openai import OpenAI
 from app.models import Message, Conversation
 from app.database import ChatDatabase
 from app.config import CONFIG, OPENAI_API_KEY, ANTHROPIC_API_KEY, OLLAMA_BASE_URL
-from app.ui.chat_interface import MessageDisplay
+# Import InputWithFocus as well
+from app.ui.chat_interface import MessageDisplay, InputWithFocus
 from app.ui.model_selector import ModelSelector, StyleSelector
 from app.ui.chat_list import ChatList
 from app.api.base import BaseModelClient
-from app.utils import generate_streaming_response, save_settings_to_config # Import save function
+from app.utils import generate_streaming_response, save_settings_to_config, generate_conversation_title # Import title function
 
 # --- Remove SettingsScreen class entirely ---
 
@@ -114,10 +115,15 @@ class HistoryScreen(Screen):
 class SimpleChatApp(App): # Keep SimpleChatApp class definition
     """Simplified Chat CLI application.""" # Keep SimpleChatApp docstring
     
-    TITLE = "Chat CLI" # Keep SimpleChatApp TITLE
+    TITLE = "Chat Console"
     SUB_TITLE = "AI Chat Interface" # Keep SimpleChatApp SUB_TITLE
     DARK = True # Keep SimpleChatApp DARK
     
+    # Ensure the log directory exists in a standard cache location
+    log_dir = os.path.expanduser("~/.cache/chat-cli")
+    os.makedirs(log_dir, exist_ok=True)
+    LOG_FILE = os.path.join(log_dir, "textual.log") # Use absolute path
+
     CSS = """ # Keep SimpleChatApp CSS start
     #main-content { # Keep SimpleChatApp CSS
         width: 100%;
@@ -209,18 +215,48 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
         padding-top: 1;
     }
 
+    /* --- Title Input Modal CSS --- */
+    TitleInputModal {
+        align: center middle;
+        width: 60;
+        height: auto;
+        background: $surface;
+        border: thick $primary;
+        padding: 1 2;
+        layer: modal; /* Ensure it's above other elements */
+    }
+
+    #modal-label {
+        width: 100%;
+        content-align: center middle;
+        padding-bottom: 1;
+    }
+
+    #title-input {
+        width: 100%;
+        margin-bottom: 1;
+    }
+
+    TitleInputModal Horizontal {
+        width: 100%;
+        height: auto;
+        align: center middle;
+    }
     """
     
     BINDINGS = [ # Keep SimpleChatApp BINDINGS, ensure Enter is not globally bound for settings
         Binding("q", "quit", "Quit", show=True, key_display="q"),
+        # Removed priority=True - actions should only trigger when input is NOT focused
         Binding("n", "action_new_conversation", "New Chat", show=True, key_display="n"),
-        Binding("c", "action_new_conversation", "New Chat", show=False, key_display="c"),
+        Binding("c", "action_new_conversation", "New Chat", show=False, key_display="c"), # Removed priority from alias
         Binding("escape", "escape", "Cancel / Stop", show=True, key_display="esc"), # Escape might close settings panel too
         Binding("ctrl+c", "quit", "Quit", show=False),
-        Binding("h", "view_history", "History", show=True, key_display="h"),
-        Binding("s", "settings", "Settings", show=True, key_display="s"),
+        Binding("h", "view_history", "History", show=True, key_display="h"), # Action method checks focus
+        Binding("s", "settings", "Settings", show=True, key_display="s"),     # Action method checks focus
+        # Removed priority=True - action should only trigger when input is NOT focused
+        Binding("t", "action_update_title", "Update Title", show=True, key_display="t"),
     ] # Keep SimpleChatApp BINDINGS end
-    
+
     current_conversation = reactive(None) # Keep SimpleChatApp reactive var
     is_generating = reactive(False) # Keep SimpleChatApp reactive var
     
@@ -231,7 +267,8 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
         self.selected_model = CONFIG["default_model"] # Keep SimpleChatApp __init__
         self.selected_style = CONFIG["default_style"] # Keep SimpleChatApp __init__
         self.initial_text = initial_text # Keep SimpleChatApp __init__
-        
+        # Removed self.input_widget instance variable
+
     def compose(self) -> ComposeResult: # Modify SimpleChatApp compose
         """Create the simplified application layout."""
         yield Header()
@@ -250,7 +287,8 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
             
             # Input area
             with Container(id="input-area"):
-                yield Input(placeholder="Type your message here...", id="message-input")
+                # Use the custom InputWithFocus widget
+                yield InputWithFocus(placeholder="Type your message here...", id="message-input")
                 # Removed Static widgets previously used for diagnosis
 
             # --- Add Settings Panel (hidden initially) ---
@@ -307,10 +345,12 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
             await self.action_send_message() # Keep SimpleChatApp on_mount
         else: # Keep SimpleChatApp on_mount
             # Focus the input if no initial text # Keep SimpleChatApp on_mount
+            # Removed assignment to self.input_widget
             self.query_one("#message-input").focus() # Keep SimpleChatApp on_mount
-        
+
     async def create_new_conversation(self) -> None: # Keep SimpleChatApp create_new_conversation
         """Create a new chat conversation.""" # Keep SimpleChatApp create_new_conversation docstring
+        log("Entering create_new_conversation") # Added log
         # Create new conversation in database using selected model and style # Keep SimpleChatApp create_new_conversation
         model = self.selected_model # Keep SimpleChatApp create_new_conversation
         style = self.selected_style # Keep SimpleChatApp create_new_conversation
@@ -319,7 +359,9 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
         title = f"New conversation ({datetime.now().strftime('%Y-%m-%d %H:%M')})" # Keep SimpleChatApp create_new_conversation
         
         # Create conversation in database using the correct method # Keep SimpleChatApp create_new_conversation
+        log(f"Creating conversation with title: {title}, model: {model}, style: {style}") # Added log
         conversation_id = self.db.create_conversation(title, model, style) # Keep SimpleChatApp create_new_conversation
+        log(f"Database returned conversation_id: {conversation_id}") # Added log
         
         # Get the full conversation data # Keep SimpleChatApp create_new_conversation
         conversation_data = self.db.get_conversation(conversation_id) # Keep SimpleChatApp create_new_conversation
@@ -333,26 +375,42 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
         
         # Clear messages and update UI # Keep SimpleChatApp create_new_conversation
         self.messages = [] # Keep SimpleChatApp create_new_conversation
+        log("Finished updating messages UI in create_new_conversation") # Added log
         await self.update_messages_ui() # Keep SimpleChatApp create_new_conversation
-        
+
     async def action_new_conversation(self) -> None: # Keep SimpleChatApp action_new_conversation
         """Handle the new conversation action.""" # Keep SimpleChatApp action_new_conversation docstring
-        await self.create_new_conversation() # Keep SimpleChatApp action_new_conversation
+        log("--- ENTERING action_new_conversation ---") # Add entry log
         
+        # Check if the currently focused widget is the input widget
+        currently_focused = self.focused
+        if currently_focused and currently_focused.id == "message-input":
+            log("action_new_conversation skipped: input has focus")
+            return
+
+        log("action_new_conversation EXECUTING") # Add execution log
+        await self.create_new_conversation() # Keep SimpleChatApp action_new_conversation
+        log("action_new_conversation finished") # Added log
+
     def action_escape(self) -> None: # Modify SimpleChatApp action_escape
         """Handle escape key globally."""
+        log("action_escape triggered") # Added log
         settings_panel = self.query_one("#settings-panel")
+        log(f"Settings panel visible: {settings_panel.has_class('visible')}") # Added log
         if settings_panel.has_class("visible"):
+            log("Hiding settings panel") # Added log
             # If settings panel is visible, hide it
             settings_panel.remove_class("visible")
             self.query_one("#message-input").focus() # Focus input after closing settings
         elif self.is_generating:
+            log("Stopping generation") # Added log
             # Otherwise, stop generation if running
             self.is_generating = False # Keep SimpleChatApp action_escape
             self.notify("Generation stopped", severity="warning") # Keep SimpleChatApp action_escape
             loading = self.query_one("#loading-indicator") # Keep SimpleChatApp action_escape
             loading.add_class("hidden") # Keep SimpleChatApp action_escape
-        # else: # Optional: Add other escape behavior for the main screen if desired # Keep SimpleChatApp action_escape comment
+        else: # Optional: Add other escape behavior for the main screen if desired # Keep SimpleChatApp action_escape comment
+            log("Escape pressed, but settings not visible and not generating.") # Added log
             # pass # Keep SimpleChatApp action_escape comment
 
     # Removed action_confirm_or_send - Enter is handled by Input submission # Keep SimpleChatApp comment
@@ -399,14 +457,62 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
             content # Keep SimpleChatApp action_send_message
         ) # Keep SimpleChatApp action_send_message
         
-        # Update UI # Keep SimpleChatApp action_send_message
-        await self.update_messages_ui() # Keep SimpleChatApp action_send_message
+        # Check if this is the first message in the conversation
+        # Note: We check length *before* adding the potential assistant message
+        is_first_message = len(self.messages) == 1 
+        
+        # Update UI with user message first
+        await self.update_messages_ui()
         
-        # Generate AI response # Keep SimpleChatApp action_send_message
-        await self.generate_response() # Keep SimpleChatApp action_send_message
+        # 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):
+            log("First message detected, generating title...")
+            title_generation_in_progress = True # Use a local flag
+            loading = self.query_one("#loading-indicator")
+            loading.remove_class("hidden") # Show loading for title gen
+            
+            try:
+                # Get appropriate client
+                model = self.selected_model
+                client = BaseModelClient.get_client_for_model(model)
+                if client is None:
+                    raise Exception(f"No client available for model: {model}")
+
+                # Generate title
+                log(f"Calling generate_conversation_title with model: {model}")
+                title = await generate_conversation_title(content, model, client)
+                log(f"Generated title: {title}")
+
+                # Update conversation title in database
+                self.db.update_conversation(
+                    self.current_conversation.id,
+                    title=title
+                )
+                
+                # Update UI title
+                title_widget = self.query_one("#conversation-title", Static)
+                title_widget.update(title)
+                
+                # Update conversation object
+                self.current_conversation.title = title
+                
+                self.notify(f"Conversation title set to: {title}", severity="information", timeout=3)
+                
+            except Exception as e:
+                log.error(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")
+
+        # Generate AI response (will set self.is_generating and handle loading indicator)
+        await self.generate_response()
         
-        # Focus back on input # Keep SimpleChatApp action_send_message
-        input_widget.focus() # Keep SimpleChatApp action_send_message
+        # Focus back on input
+        input_widget.focus()
     
     async def generate_response(self) -> None: # Keep SimpleChatApp generate_response
         """Generate an AI response.""" # Keep SimpleChatApp generate_response docstring
@@ -414,6 +520,7 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
             return # Keep SimpleChatApp generate_response
             
         self.is_generating = True # Keep SimpleChatApp generate_response
+        log(f"Setting is_generating to True") # Added log
         loading = self.query_one("#loading-indicator") # Keep SimpleChatApp generate_response
         loading.remove_class("hidden") # Keep SimpleChatApp generate_response
         
@@ -455,6 +562,7 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
             
             async def update_ui(content: str): # Keep SimpleChatApp generate_response
                 if not self.is_generating: # Keep SimpleChatApp generate_response
+                    log("update_ui called but is_generating is False, returning.") # Added log
                     return # Keep SimpleChatApp generate_response
                 
                 async with update_lock: # Keep SimpleChatApp generate_response
@@ -474,7 +582,7 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                         # Force another refresh to ensure content is visible # Keep SimpleChatApp generate_response
                         self.refresh(layout=True) # Keep SimpleChatApp generate_response
                     except Exception as e: # Keep SimpleChatApp generate_response
-                        logger.error(f"Error updating UI: {str(e)}") # Keep SimpleChatApp generate_response
+                        log.error(f"Error updating UI: {str(e)}") # Use log instead of logger
                 
             # Generate the response with timeout and cleanup # Keep SimpleChatApp generate_response
             generation_task = None # Keep SimpleChatApp generate_response
@@ -482,6 +590,7 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                 # Create a task for the response generation # Keep SimpleChatApp generate_response
                 generation_task = asyncio.create_task( # Keep SimpleChatApp generate_response
                     generate_streaming_response( # Keep SimpleChatApp generate_response
+                        self, # Pass the app instance
                         api_messages, # Keep SimpleChatApp generate_response
                         model, # Keep SimpleChatApp generate_response
                         style, # Keep SimpleChatApp generate_response
@@ -495,6 +604,7 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                 
                 # Save to database only if we got a complete response # Keep SimpleChatApp generate_response
                 if self.is_generating and full_response: # Keep SimpleChatApp generate_response
+                    log("Generation finished, saving full response to DB") # Added log
                     self.db.add_message( # Keep SimpleChatApp generate_response
                         self.current_conversation.id, # Keep SimpleChatApp generate_response
                         "assistant", # Keep SimpleChatApp generate_response
@@ -503,9 +613,11 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                     # Force a final refresh # Keep SimpleChatApp generate_response
                     self.refresh(layout=True) # Keep SimpleChatApp generate_response
                     await asyncio.sleep(0.1)  # Wait for UI to update # Keep SimpleChatApp generate_response
+                elif not full_response:
+                    log("Generation finished but full_response is empty/None") # Added log
                     
             except asyncio.TimeoutError: # Keep SimpleChatApp generate_response
-                logger.error("Response generation timed out") # Keep SimpleChatApp generate_response
+                log.error("Response generation timed out") # Use log instead of logger
                 error_msg = "Response generation timed out. The model may be busy or unresponsive. Please try again." # Keep SimpleChatApp generate_response
                 self.notify(error_msg, severity="error") # Keep SimpleChatApp generate_response
                 
@@ -520,22 +632,25 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
                 # Ensure task is properly cancelled and cleaned up # Keep SimpleChatApp generate_response
                 if generation_task: # Keep SimpleChatApp generate_response
                     if not generation_task.done(): # Keep SimpleChatApp generate_response
+                        log("Cancelling generation task") # Added log
                         generation_task.cancel() # Keep SimpleChatApp generate_response
                         try: # Keep SimpleChatApp generate_response
                             await generation_task # Keep SimpleChatApp generate_response
                         except (asyncio.CancelledError, Exception) as e: # Keep SimpleChatApp generate_response
-                            logger.error(f"Error cleaning up generation task: {str(e)}") # Keep SimpleChatApp generate_response
+                            log.error(f"Error cleaning up generation task: {str(e)}") # Use log instead of logger
                     
                 # Force a final UI refresh # Keep SimpleChatApp generate_response
                 self.refresh(layout=True) # Keep SimpleChatApp generate_response
                 
         except Exception as e: # Keep SimpleChatApp generate_response
+            log.error(f"Exception during generate_response: {str(e)}") # Added log
             self.notify(f"Error generating response: {str(e)}", severity="error") # Keep SimpleChatApp generate_response
             # Add error message # Keep SimpleChatApp generate_response
             error_msg = f"Error generating response: {str(e)}" # Keep SimpleChatApp generate_response
             self.messages.append(Message(role="assistant", content=error_msg)) # Keep SimpleChatApp generate_response
             await self.update_messages_ui() # Keep SimpleChatApp generate_response
         finally: # Keep SimpleChatApp generate_response
+            log(f"Setting is_generating to False in finally block") # Added log
             self.is_generating = False # Keep SimpleChatApp generate_response
             loading = self.query_one("#loading-indicator") # Keep SimpleChatApp generate_response
             loading.add_class("hidden") # Keep SimpleChatApp generate_response
@@ -648,6 +763,89 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
             else:
                  input_widget.focus() # Focus input when closing
 
+    async def action_update_title(self) -> None:
+        """Allow users to manually change the conversation title"""
+        log("--- ENTERING action_update_title ---") # Add entry log
+        
+        # Check focus using self.focused instead of has_focus
+        currently_focused = self.focused
+        if currently_focused and currently_focused.id == "message-input":
+            log("action_update_title skipped: input has focus")
+            return
+
+        log("action_update_title EXECUTING") # Add execution log
+
+        if not self.current_conversation:
+            self.notify("No active conversation", severity="warning")
+            return
+
+        # --- Define the Modal Class ---
+        class TitleInputModal(Static):
+            def __init__(self, current_title: str):
+                super().__init__()
+                self.current_title = current_title
+
+            def compose(self) -> ComposeResult:
+                with Vertical(id="title-modal"):
+                    yield Static("Enter new conversation title:", id="modal-label")
+                    yield Input(value=self.current_title, id="title-input")
+                    with Horizontal():
+                        yield Button("Cancel", id="cancel-button", variant="error")
+                        yield Button("Update", id="update-button", variant="success")
+
+            @on(Button.Pressed, "#update-button")
+            def update_title(self, event: Button.Pressed) -> None:
+                input_widget = self.query_one("#title-input", Input)
+                new_title = input_widget.value.strip()
+                if new_title:
+                    # Call the app's update method asynchronously
+                    asyncio.create_task(self.app.update_conversation_title(new_title))
+                self.remove() # Close the modal
+
+            @on(Button.Pressed, "#cancel-button")
+            def cancel(self, event: Button.Pressed) -> None:
+                self.remove() # Close the modal
+
+            def on_mount(self) -> None:
+                """Focus the input when the modal appears."""
+                self.query_one("#title-input", Input).focus()
+
+        # --- Show the modal ---
+        modal = TitleInputModal(self.current_conversation.title)
+        await self.mount(modal) # Use await for mounting
+
+    async def update_conversation_title(self, new_title: str) -> None:
+        """Update the current conversation title"""
+        if not self.current_conversation:
+            return
+
+        try:
+            # Update in database
+            self.db.update_conversation(
+                self.current_conversation.id,
+                title=new_title
+            )
+
+            # Update local object
+            self.current_conversation.title = new_title
+
+            # Update UI
+            title_widget = self.query_one("#conversation-title", Static)
+            title_widget.update(new_title)
+
+            # Update any chat list if visible
+            # Attempt to refresh ChatList if it exists
+            try:
+                chat_list = self.query_one(ChatList)
+                chat_list.refresh() # Call the refresh method
+            except Exception:
+                pass # Ignore if ChatList isn't found or refresh fails
+
+            self.notify("Title updated successfully", severity="information")
+        except Exception as e:
+            self.notify(f"Failed to update title: {str(e)}", severity="error")
+
+
 def main(initial_text: Optional[str] = typer.Argument(None, help="Initial text to start the chat with")): # Keep main function
     """Entry point for the chat-cli application""" # Keep main function docstring
     # When no argument is provided, typer passes the ArgumentInfo object # Keep main function

{chat_console-0.1.95.dev1 → chat_console-0.1.991.dev1}/app/ui/chat_interface.py

@@ -129,20 +129,23 @@ class MessageDisplay(RichLog):
 
 class InputWithFocus(Input):
     """Enhanced Input that better handles focus and maintains cursor position"""
-    
+    # Reverted on_key to default Input behavior for 'n' and 't'
+    # Let the standard Input handle key presses when focused.
+    # We will rely on focus checks within the App's action methods.
+
+    # Keep custom handling only for Enter submission if needed,
+    # but standard Input might already do this. Let's simplify
+    # and remove the custom on_key entirely for now unless
     def on_key(self, event) -> None:
-        """Custom key handling for input"""
-        # Let control keys pass through
-        if event.is_control:
-            return super().on_key(event)
-            
-        # Handle Enter key
-        if event.key == "enter":
-            self.post_message(self.Submitted(self))
-            return
-            
-        # Normal input handling for other keys
-        super().on_key(event)
+        # Let global hotkeys 'n' and 't' pass through even when input has focus
+        # by simply *not* stopping the event here.
+        if event.key == "n" or event.key == "t":
+            # Do nothing, allow the event to bubble up to the app level bindings.
+            return # Explicitly return to prevent further processing in this method
+
+        # For all other keys, the event continues to be processed by the Input
+        # widget's internal handlers (like _on_key shown in the traceback)
+        # because we didn't stop it in this method.
 
 class ChatInterface(Container):
     """Main chat interface container"""

chat_console-0.1.991.dev1/app/utils.py

@@ -0,0 +1,194 @@
+import os
+import json
+import time
+import asyncio
+import subprocess
+import logging
+from typing import Optional, Dict, Any, List, TYPE_CHECKING
+from datetime import datetime
+from .config import CONFIG, save_config
+
+# Import SimpleChatApp for type hinting only if TYPE_CHECKING is True
+if TYPE_CHECKING:
+    from .main import SimpleChatApp
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+async def generate_conversation_title(message: str, model: str, client: Any) -> str:
+    """Generate a descriptive title for a conversation based on the first message"""
+    logger.info(f"Generating title for conversation using model: {model}")
+    
+    # Create a special prompt for title generation
+    title_prompt = [
+        {
+            "role": "system", 
+            "content": "Generate a brief, descriptive title (maximum 40 characters) for a conversation that starts with the following message. The title should be concise and reflect the main topic or query. Return only the title text with no additional explanation or formatting."
+        },
+        {
+            "role": "user",
+            "content": message
+        }
+    ]
+    
+    tries = 2  # Number of retries
+    last_error = None
+    
+    while tries > 0:
+        try:
+            # Generate a title using the same model but with a separate request
+            # Assuming client has a method like generate_completion or similar
+            # Adjust the method call based on the actual client implementation
+            if hasattr(client, 'generate_completion'):
+                title = await client.generate_completion(
+                    messages=title_prompt,
+                    model=model,
+                    temperature=0.7,
+                    max_tokens=60  # Titles should be short
+                )
+            elif hasattr(client, 'generate_stream'): # Fallback or alternative method?
+                 # If generate_completion isn't available, maybe adapt generate_stream?
+                 # This part needs clarification based on the client's capabilities.
+                 # For now, let's assume a hypothetical non-streaming call or adapt stream
+                 # Simplified adaptation: collect stream chunks
+                 title_chunks = []
+                 async for chunk in client.generate_stream(title_prompt, model, style=""): # Assuming style might not apply or needs default
+                     title_chunks.append(chunk)
+                 title = "".join(title_chunks)
+            else:
+                 raise NotImplementedError("Client does not support a suitable method for title generation.")
+
+            # Sanitize and limit the title
+            title = title.strip().strip('"\'').strip()
+            if len(title) > 40:  # Set a maximum title length
+                title = title[:37] + "..."
+                
+            logger.info(f"Generated title: {title}")
+            return title # Return successful title
+            
+        except Exception as e:
+            last_error = str(e)
+            logger.error(f"Error generating title (tries left: {tries - 1}): {last_error}")
+            tries -= 1
+            if tries > 0: # Only sleep if there are more retries
+                await asyncio.sleep(1)  # Small delay before retry
+    
+    # If all retries fail, log the last error and return a default title
+    logger.error(f"Failed to generate title after multiple retries. Last error: {last_error}")
+    return f"Conversation ({datetime.now().strftime('%Y-%m-%d %H:%M')})"
+
+# Modified signature to accept app instance
+async def generate_streaming_response(app: 'SimpleChatApp', 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 = ""
+    buffer = []
+    last_update = time.time()
+    update_interval = 0.1  # Update UI every 100ms
+    
+    try:
+        async for chunk in client.generate_stream(messages, model, style):
+            # Check if generation was cancelled by the app (e.g., via escape key)
+            if not app.is_generating:
+                logger.info("Generation cancelled by app flag.")
+                break # Exit the loop immediately
+
+            if chunk:  # Only process non-empty chunks
+                buffer.append(chunk)
+                current_time = time.time()
+                
+                # Update UI if enough time has passed or buffer is large
+                if current_time - last_update >= update_interval or len(''.join(buffer)) > 100:
+                    new_content = ''.join(buffer)
+                    full_response += new_content
+                    # Check again before calling callback, in case it was cancelled during chunk processing
+                    if not app.is_generating:
+                        logger.info("Generation cancelled before UI update.")
+                        break
+                    await callback(full_response)
+                    buffer = []
+                    last_update = current_time
+                    
+                    # Small delay to let UI catch up
+                    await asyncio.sleep(0.05)
+        
+        # Send any remaining content if generation wasn't cancelled
+        if buffer and app.is_generating:
+            new_content = ''.join(buffer)
+            full_response += new_content
+            await callback(full_response)
+        
+        if app.is_generating:
+            logger.info("Streaming response completed normally.")
+        else:
+             logger.info("Streaming response loop exited due to cancellation.")
+             
+        return full_response
+    except Exception as e:
+        logger.error(f"Error in streaming response: {str(e)}")
+        # Ensure the app knows generation stopped on error
+        app.is_generating = False
+        raise
+
+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)}")
+    
+    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.95.dev1 → chat_console-0.1.991.dev1}/chat_console.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chat-console
-Version: 0.1.95.dev1
+Version: 0.1.991.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.95.dev1 → chat_console-0.1.991.dev1}/setup.py

@@ -14,7 +14,7 @@ with open(os.path.join("app", "__init__.py"), "r", encoding="utf-8") as f:
 
 setup(
     name="chat-console",
-    version="0.1.95.dev1",
+    version="0.1.991.dev1",
     author="Johnathan Greenaway",
     author_email="john@fimbriata.dev",
     description="A command-line interface for chatting with LLMs, storing chats and (future) rag interactions",

chat_console-0.1.95.dev1/app/utils.py

@@ -1,111 +0,0 @@
-import os
-import json
-import time
-import asyncio
-import subprocess
-import logging
-from typing import Optional, Dict, Any, List
-from .config import CONFIG, save_config
-
-# Set up logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-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 = ""
-    buffer = []
-    last_update = time.time()
-    update_interval = 0.1  # Update UI every 100ms
-    
-    try:
-        async for chunk in client.generate_stream(messages, model, style):
-            if chunk:  # Only process non-empty chunks
-                buffer.append(chunk)
-                current_time = time.time()
-                
-                # Update UI if enough time has passed or buffer is large
-                if current_time - last_update >= update_interval or len(''.join(buffer)) > 100:
-                    new_content = ''.join(buffer)
-                    full_response += new_content
-                    await callback(full_response)
-                    buffer = []
-                    last_update = current_time
-                    
-                    # Small delay to let UI catch up
-                    await asyncio.sleep(0.05)
-        
-        # Send any remaining content
-        if buffer:
-            new_content = ''.join(buffer)
-            full_response += new_content
-            await callback(full_response)
-        
-        logger.info("Streaming response completed")
-        return full_response
-    except Exception as e:
-        logger.error(f"Error in streaming response: {str(e)}")
-        raise
-
-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)}")
-    
-    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)