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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chat-console
-Version: 0.1.95.dev1
+Version: 0.1.96.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.96.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.96.dev1}/app/main.py

@@ -13,7 +13,7 @@ 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
@@ -23,7 +23,7 @@ from app.ui.chat_interface import MessageDisplay
 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 ---
 
@@ -209,6 +209,33 @@ 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
@@ -219,6 +246,7 @@ class SimpleChatApp(App): # Keep SimpleChatApp class definition
         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("t", "action_update_title", "Update Title", show=True, key_display="t"),
     ] # Keep SimpleChatApp BINDINGS end
     
     current_conversation = reactive(None) # Keep SimpleChatApp reactive var
@@ -399,14 +427,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 
         
-        # Generate AI response # Keep SimpleChatApp action_send_message
-        await self.generate_response() # Keep SimpleChatApp action_send_message
+        # Update UI with user message first
+        await self.update_messages_ui()
         
-        # Focus back on input # Keep SimpleChatApp action_send_message
-        input_widget.focus() # 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
+        input_widget.focus()
     
     async def generate_response(self) -> None: # Keep SimpleChatApp generate_response
         """Generate an AI response.""" # Keep SimpleChatApp generate_response docstring
@@ -648,6 +724,79 @@ 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"""
+        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.96.dev1}/app/utils.py

@@ -5,12 +5,75 @@ import asyncio
 import subprocess
 import logging
 from typing import Optional, Dict, Any, List
+from datetime import datetime
 from .config import CONFIG, save_config
 
 # 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')})"
+
 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}")

{chat_console-0.1.95.dev1 → chat_console-0.1.96.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.96.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.96.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.96.dev1",
     author="Johnathan Greenaway",
     author_email="john@fimbriata.dev",
     description="A command-line interface for chatting with LLMs, storing chats and (future) rag interactions",