grucli 3.3.0__py3-none-any.whl

grucli/auth.py

@@ -0,0 +1,115 @@
+import os
+import json
+import webbrowser
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from urllib.parse import urlparse, parse_qs
+import threading
+import requests
+from datetime import datetime
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+from google.auth.transport.requests import Request
+
+from . import config
+
+OAUTH_CLIENT_ID = '681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com'
+OAUTH_CLIENT_SECRET = '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'
+OAUTH_SCOPES = [
+    'https://www.googleapis.com/auth/cloud-platform',
+    'https://www.googleapis.com/auth/userinfo.email',
+    'https://www.googleapis.com/auth/userinfo.profile',
+    'openid',
+]
+
+os.environ['OAUTHLIB_RELAX_TOKEN_SCOPE'] = '1'
+
+def get_oauth_file_path():
+    return os.path.join(config.get_config_dir(), 'google_auth.json')
+
+def get_oauth_credentials():
+    creds = None
+    oauth_file = get_oauth_file_path()
+    if os.path.exists(oauth_file):
+        try:
+            with open(oauth_file, 'r') as f:
+                creds_data = json.load(f)
+                
+                expiry = None
+                if creds_data.get('expiry'):
+                    expiry_str = creds_data.get('expiry')
+                    if expiry_str.endswith('Z'):
+                        expiry_str = expiry_str[:-1] + '+00:00'
+                    expiry = datetime.fromisoformat(expiry_str)
+
+                creds = Credentials(
+                    token=creds_data.get('access_token'),
+                    refresh_token=creds_data.get('refresh_token'),
+                    token_uri='https://oauth2.googleapis.com/token',
+                    client_id=OAUTH_CLIENT_ID,
+                    client_secret=OAUTH_CLIENT_SECRET,
+                    scopes=creds_data.get('scope').split() if creds_data.get('scope') else OAUTH_SCOPES,
+                    expiry=expiry
+                )
+        except Exception as e:
+            print(f"Error loading credentials: {e}")
+
+    if not creds or not creds.valid:
+        if creds and creds.expired and creds.refresh_token:
+            try:
+                creds.refresh(Request())
+                save_oauth_credentials(creds)
+            except Exception as e:
+                print(f"Error refreshing credentials: {e}")
+                creds = None
+        else:
+            creds = None
+
+    return creds
+
+def save_oauth_credentials(creds):
+    oauth_file = get_oauth_file_path()
+    os.makedirs(os.path.dirname(oauth_file), exist_ok=True)
+    
+    creds_data = {
+        'access_token': creds.token,
+        'refresh_token': creds.refresh_token,
+        'scope': ' '.join(creds.scopes) if creds.scopes else None,
+        'token_type': 'Bearer',
+        'expiry': creds.expiry.isoformat() if creds.expiry else None
+    }
+    
+    with open(oauth_file, 'w') as f:
+        json.dump(creds_data, f, indent=2)
+
+def perform_oauth_login():
+    client_config = {
+        "installed": {
+            "client_id": OAUTH_CLIENT_ID,
+            "client_secret": OAUTH_CLIENT_SECRET,
+            "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+            "token_uri": "https://oauth2.googleapis.com/token",
+        }
+    }
+    
+    flow = InstalledAppFlow.from_client_config(client_config, OAUTH_SCOPES)
+    
+    print("\n\033[94m--- Google OAuth Login ---\033[0m")
+    print("1. A browser window should open automatically.")
+    print("2. If it doesn't, look for a URL in the console below.")
+    print("3. Follow the instructions to authorize the application.")
+    print("--------------------------\n")
+    
+    try:
+        creds = flow.run_local_server(port=0)
+        save_oauth_credentials(creds)
+        print("\n\033[92mLogin successful! Credentials saved.\033[0m")
+        return creds
+    except Exception as e:
+        print(f"\n\033[91mOAuth login failed: {e}\033[0m")
+        raise e
+
+def get_auth_token():
+    creds = get_oauth_credentials()
+    if creds:
+        return creds.token
+    return None

grucli/chat_manager.py

@@ -0,0 +1,190 @@
+"""
+Chat management for grucli - handles saving, loading and managing chat histories.
+"""
+import os
+import json
+import time
+from datetime import datetime
+from .theme import Colors, Icons, Borders
+from . import interrupt
+from . import ui
+
+CHATS_DIR = os.path.expanduser("~/.grucli/chats/")
+
+def ensure_chats_dir():
+    """Ensure the chats directory exists."""
+    if not os.path.exists(CHATS_DIR):
+        os.makedirs(CHATS_DIR)
+
+def get_chat_path(name):
+    """Get the full path for a chat file."""
+    # Simple slugify to avoid issues with filenames
+    safe_name = "".join(c for c in name if c.isalnum() or c in (' ', '-', '_')).strip()
+    return os.path.join(CHATS_DIR, f"{safe_name}.json")
+
+def save_chat(name, messages, model, provider):
+    """Save the current chat history."""
+    ensure_chats_dir()
+    path = get_chat_path(name)
+    
+    chat_data = {
+        "name": name,
+        "messages": messages,
+        "model": model,
+        "provider": provider,
+        "last_opened": datetime.now().isoformat(),
+        "version": 1
+    }
+    
+    with open(path, 'w', encoding='utf-8') as f:
+        json.dump(chat_data, f, indent=2, ensure_ascii=False)
+    
+    return path
+
+def load_chat(name):
+    """Load a chat history by name."""
+    path = get_chat_path(name)
+    if not os.path.exists(path):
+        return None
+        
+    with open(path, 'r', encoding='utf-8') as f:
+        chat_data = json.load(f)
+    
+    # Update last opened time
+    chat_data["last_opened"] = datetime.now().isoformat()
+    with open(path, 'w', encoding='utf-8') as f:
+        json.dump(chat_data, f, indent=2, ensure_ascii=False)
+        
+    return chat_data
+
+def list_chats():
+    """List all saved chats with metadata."""
+    ensure_chats_dir()
+    chats = []
+    for filename in os.listdir(CHATS_DIR):
+        if filename.endswith(".json"):
+            try:
+                with open(os.path.join(CHATS_DIR, filename), 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    chats.append({
+                        "name": data.get("name", filename[:-5]),
+                        "filename": filename,
+                        "last_opened": data.get("last_opened", "Unknown"),
+                        "model": data.get("model", "unknown")
+                    })
+            except Exception:
+                continue
+                
+    # Sort by last opened (newest first)
+    chats.sort(key=lambda x: x["last_opened"], reverse=True)
+    return chats
+
+def delete_chat(name):
+    """Delete a saved chat."""
+    path = get_chat_path(name)
+    if os.path.exists(path):
+        os.remove(path)
+        return True
+    return False
+
+def rename_chat(old_name, new_name):
+    """Rename a saved chat."""
+    old_path = get_chat_path(old_name)
+    new_path = get_chat_path(new_name)
+    
+    if os.path.exists(old_path):
+        if os.path.exists(new_path):
+            return False, "A chat with that name already exists."
+            
+        with open(old_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+            
+        data["name"] = new_name
+        
+        with open(new_path, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+            
+        os.remove(old_path)
+        return True, None
+    return False, "Original chat not found."
+
+def manage_chats_ui():
+    """Interactive UI to manage chats."""
+    while True:
+        chats = list_chats()
+        if not chats:
+            print(f"\n{Colors.WARNING}No saved chats found.{Colors.RESET}\n")
+            return None
+
+        title = "Manage Saved Chats"
+        options = []
+        for chat in chats:
+            # Format last opened time for display
+            try:
+                dt = datetime.fromisoformat(chat["last_opened"])
+                last_opened_str = dt.strftime("%Y-%m-%d %H:%M")
+            except Exception:
+                last_opened_str = chat["last_opened"]
+                
+            label = f"{chat['name']} ({Colors.MUTED}{chat['model']}, {last_opened_str}{Colors.RESET})"
+            options.append(label)
+        
+        options.append(f"{Colors.MUTED}Back to chat{Colors.RESET}")
+
+        try:
+            result = ui.select_option(options, title)
+            if not result:
+                return None
+            
+            _, selected_index = result
+            
+            # Check if 'Back to chat' was selected (it's the last option)
+            if selected_index == len(chats):
+                return None
+                
+            selected_chat = chats[selected_index]
+            selected_chat_name = selected_chat['name']
+            
+            # Action menu for the selected chat
+            action_title = f"Chat: {selected_chat_name}"
+            actions = [
+                f"{Colors.SUCCESS}{Icons.CHECK} Load Chat{Colors.RESET}",
+                f"{Colors.WARNING} Rename Chat{Colors.RESET}",
+                f"{Colors.ERROR}{Icons.CROSS} Delete Chat{Colors.RESET}",
+                f"{Colors.MUTED}Cancel{Colors.RESET}"
+            ]
+            
+            action_result = ui.select_option(actions, action_title)
+            if not action_result:
+                continue
+                
+            _, action_index = action_result
+            
+            if action_index == 0: # Load
+                return selected_chat_name
+            elif action_index == 1: # Rename
+                print(f"\n{Colors.MUTED}Enter new name for '{selected_chat_name}':{Colors.RESET}")
+                new_name = interrupt.safe_input(f"{Colors.INPUT_ACTIVE}> {Colors.RESET}").strip()
+                if new_name:
+                    success, err = rename_chat(selected_chat_name, new_name)
+                    if success:
+                        print(f"{Colors.SUCCESS}{Icons.CHECK} Chat renamed to '{new_name}'.{Colors.RESET}")
+                        time.sleep(1)
+                    else:
+                        print(f"{Colors.ERROR}{Icons.CROSS} {err}{Colors.RESET}")
+                        time.sleep(2)
+            elif action_index == 2: # Delete
+                confirm = interrupt.safe_input(f"{Colors.WARNING}Delete chat '{selected_chat_name}'? (y/n): {Colors.RESET}").strip().lower()
+                if confirm == 'y':
+                    if delete_chat(selected_chat_name):
+                        print(f"{Colors.SUCCESS}{Icons.CHECK} Chat deleted.{Colors.RESET}")
+                        time.sleep(1)
+                    else:
+                        print(f"{Colors.ERROR}{Icons.CROSS} Failed to delete chat.{Colors.RESET}")
+                        time.sleep(2)
+            # action_index == 3 is Cancel, which just loops back
+                        
+        except interrupt.BackSignal:
+            return None
+        except KeyboardInterrupt:
+            return None

grucli/commands.py

@@ -0,0 +1,318 @@
+"""
+Command handling for grucli slash commands.
+"""
+
+from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.formatted_text import HTML
+from . import api
+from . import config
+from . import tools
+from . import auth
+from . import interrupt
+from . import chat_manager
+from . import ui
+from .theme import Colors, Icons, Borders
+import os
+import time
+
+CMD_LIST = ['/exit', '/clear', '/help', '/model', '/manage-api-keys', '/gemini-login', '/gemini-auth-mode', '/show-reasoning', '/save', '/load', '/manage-chats']
+
+
+class ChatCompleter(Completer):
+    """Completer for slash commands and @file mentions."""
+    
+    def __init__(self):
+        self._file_cache = []
+        self._last_cache_time = 0
+
+    def get_completions(self, document, complete_event):
+        text_before_cursor = document.text_before_cursor
+        if not text_before_cursor:
+            return
+
+        last_space = text_before_cursor.rfind(' ')
+        current_word = text_before_cursor[last_space+1:]
+
+        if text_before_cursor.startswith('/') and ' ' not in text_before_cursor:
+            for cmd in CMD_LIST:
+                if cmd.startswith(text_before_cursor):
+                    yield Completion(
+                        cmd,
+                        start_position=-len(text_before_cursor),
+                        display=HTML(f'<style color="#af5fff">{cmd}</style>')
+                    )
+            return
+
+        if text_before_cursor.startswith('/load ') and ' ' not in text_before_cursor[6:]:
+            chat_prefix = text_before_cursor[6:].lower()
+            chats = chat_manager.list_chats()
+            for chat in chats:
+                name = chat['name']
+                if name.lower().startswith(chat_prefix):
+                    yield Completion(
+                        name,
+                        start_position=-len(chat_prefix),
+                        display=HTML(f'<style color="#af5fff">{name}</style>')
+                    )
+            return
+
+        if '@' in current_word:
+            at_idx = current_word.rfind('@')
+            mention = current_word[at_idx+1:]
+            mention_lower = mention.lower()
+            
+            # Simple cache to avoid walking disk on every character
+            now = time.time()
+            if now - self._last_cache_time > 5:
+                self._file_cache = tools.list_files_recursive()
+                self._last_cache_time = now
+                
+            for file_path in self._file_cache:
+                if mention_lower in file_path.lower():
+                    yield Completion(
+                        file_path,
+                        start_position=-len(mention),
+                        display=HTML(f'<style color="#af5fff">@{file_path}</style>')
+                    )
+
+
+completer = ChatCompleter()
+
+
+def manage_api_key(api_type='gemini'):
+    """Manage saved API keys."""
+    api_name = api_type.capitalize()
+    
+    print(f"\n{Colors.PRIMARY}{Colors.BOLD}{api_name} API Key Management{Colors.RESET}")
+    print(f"{Colors.MUTED}{Borders.HORIZONTAL * 30}{Colors.RESET}\n")
+    
+    print(f"  {Colors.SUCCESS}1{Colors.RESET}) Change stored API key")
+    print(f"  {Colors.WARNING}2{Colors.RESET}) Change password")
+    print(f"  {Colors.ERROR}3{Colors.RESET}) Remove stored API key")
+    print(f"  {Colors.MUTED}4{Colors.RESET}) Cancel")
+    print()
+    
+    choice = interrupt.safe_input(f"{Colors.INPUT_ACTIVE}Choose (1-4): {Colors.RESET}").strip()
+
+    if choice == '1':
+        if config.has_saved_api_key(api_type):
+            print(f"\n{Colors.MUTED}Enter new {api_name} API key:{Colors.RESET}")
+            new_api_key = interrupt.safe_input(f"{Colors.INPUT_ACTIVE}> {Colors.RESET}").strip()
+            if new_api_key:
+                config.save_encrypted_api_key(new_api_key, api_type)
+                print(f"{Colors.SUCCESS}{Icons.CHECK} API key updated.{Colors.RESET}")
+            else:
+                print(f"{Colors.WARNING}No API key provided.{Colors.RESET}")
+        else:
+            print(f"{Colors.WARNING}No saved API key found. Use the main interface to save a new API key.{Colors.RESET}")
+
+    elif choice == '2':
+        config.change_encrypted_api_key_password(api_type)
+
+    elif choice == '3':
+        config.remove_saved_api_key(api_type)
+
+    elif choice == '4':
+        print(f"{Colors.MUTED}Cancelled.{Colors.RESET}")
+    else:
+        print(f"{Colors.ERROR}Invalid option. Please choose 1-4.{Colors.RESET}")
+
+
+def handle_command(cmd, state):
+    """Handle slash commands."""
+    c = cmd.lower().strip()
+    
+    if c == '/exit':
+        return "exit"
+        
+    elif c == '/clear':
+        # Reload custom prompt on clear
+        sys_prompt = api.get_system_prompt()
+        state['messages'] = [{"role": "system", "content": sys_prompt}]
+        print(f"{Colors.SUCCESS}{Icons.CHECK} Chat cleared.{Colors.RESET}\n")
+        return "continue"
+        
+    elif c == '/help':
+        print(f"\n{Colors.PRIMARY}{Colors.BOLD}Available Commands{Colors.RESET}")
+        print(f"{Colors.MUTED}{Borders.HORIZONTAL * 40}{Colors.RESET}\n")
+        
+        commands_help = [
+            ('/help', 'Show this help message'),
+            ('/exit', 'Exit the application'),
+            ('/clear', 'Clear the current chat history'),
+            ('/model', 'Switch between different models'),
+            ('/manage-api-keys', 'Manage your saved API keys'),
+            ('/gemini-login', 'Login with your Google account'),
+            ('/gemini-auth-mode', 'Toggle Google Auth vs API Key mode'),
+            ('/show-reasoning', 'Toggle showing reasoning tokens [true/false]'),
+            ('/save [name]', 'Save current chat history'),
+            ('/load [name]', 'Load a saved chat history'),
+            ('/manage-chats', 'Manage (load/rename/delete) saved chats'),
+        ]
+        
+        for cmd_name, desc in commands_help:
+            print(f"  {Colors.SECONDARY}{cmd_name:20}{Colors.RESET} {Colors.MUTED}{desc}{Colors.RESET}")
+        
+        print(f"\n{Colors.MUTED}Tip: Use @filename to attach file contents to your message.{Colors.RESET}\n")
+        return "continue"
+        
+    elif c == '/model':
+        return "select_model"
+        
+    elif c == '/manage-api-keys':
+        print(f"\n{Colors.PRIMARY}{Colors.BOLD}Select API to Manage{Colors.RESET}")
+        print(f"{Colors.MUTED}{Borders.HORIZONTAL * 25}{Colors.RESET}\n")
+        
+        print(f"  {Colors.SUCCESS}1{Colors.RESET}) OpenAI API")
+        print(f"  {Colors.SUCCESS}2{Colors.RESET}) Anthropic API")
+        print(f"  {Colors.SUCCESS}3{Colors.RESET}) Gemini API")
+        print(f"  {Colors.SUCCESS}4{Colors.RESET}) Cerebras API")
+        print(f"  {Colors.MUTED}5{Colors.RESET}) Cancel")
+        print()
+
+        choice = interrupt.safe_input(f"{Colors.INPUT_ACTIVE}Choose (1-5): {Colors.RESET}").strip()
+        if choice == '1':
+            manage_api_key('openai')
+        elif choice == '2':
+            manage_api_key('anthropic')
+        elif choice == '3':
+            manage_api_key('gemini')
+        elif choice == '4':
+            manage_api_key('cerebras')
+        elif choice == '5':
+            print(f"{Colors.MUTED}Cancelled.{Colors.RESET}")
+        else:
+            print(f"{Colors.ERROR}Invalid option.{Colors.RESET}")
+
+        return "continue"
+        
+    elif c == '/gemini-login':
+        print(f"\n{Colors.INFO}Starting Google OAuth login flow...{Colors.RESET}")
+        try:
+            auth.perform_oauth_login()
+            print(f"{Colors.SUCCESS}{Icons.CHECK} Successfully logged in with Google!{Colors.RESET}")
+            config.set_use_google_auth(True)
+            print(f"{Colors.MUTED}Switched to Google Auth mode.{Colors.RESET}")
+        except Exception as e:
+            print(f"{Colors.ERROR}{Icons.CROSS} Login failed: {e}{Colors.RESET}")
+        return "continue"
+        
+    elif c == '/gemini-auth-mode':
+        current_mode = "Google Auth" if config.is_using_google_auth() else "Gemini API Key"
+        print(f"\n{Colors.PRIMARY}{Colors.BOLD}Gemini Authentication Mode{Colors.RESET}")
+        print(f"{Colors.MUTED}{Borders.HORIZONTAL * 30}{Colors.RESET}")
+        print(f"\n{Colors.MUTED}Current mode:{Colors.RESET} {Colors.SECONDARY}{current_mode}{Colors.RESET}")
+        
+        if config.is_using_google_auth():
+            project_id = os.environ.get('GOOGLE_CLOUD_PROJECT') or os.environ.get('GOOGLE_CLOUD_PROJECT_ID') or config.get_google_cloud_project()
+            print(f"{Colors.MUTED}Project ID:{Colors.RESET} {Colors.SECONDARY}{project_id or 'Not set'}{Colors.RESET}")
+        
+        print(f"\n  {Colors.SUCCESS}1{Colors.RESET}) Use Google Auth (Login with Google)")
+        print(f"  {Colors.SUCCESS}2{Colors.RESET}) Use Gemini API Key")
+        print(f"  {Colors.WARNING}3{Colors.RESET}) Set Google Cloud Project ID")
+        print(f"  {Colors.MUTED}4{Colors.RESET}) Cancel")
+        print()
+        
+        choice = interrupt.safe_input(f"{Colors.INPUT_ACTIVE}Choose (1-4): {Colors.RESET}").strip()
+        if choice == '1':
+            config.set_use_google_auth(True)
+            print(f"{Colors.SUCCESS}{Icons.CHECK} Switched to Google Auth mode.{Colors.RESET}")
+            if not auth.get_auth_token():
+                print(f"{Colors.MUTED}No active session found. Starting login...{Colors.RESET}")
+                auth.perform_oauth_login()
+        elif choice == '2':
+            config.set_use_google_auth(False)
+            print(f"{Colors.SUCCESS}{Icons.CHECK} Switched to Gemini API Key mode.{Colors.RESET}")
+        elif choice == '3':
+            new_project_id = interrupt.safe_input(f"{Colors.INPUT_ACTIVE}Enter Project ID: {Colors.RESET}").strip()
+            if new_project_id:
+                config.set_google_cloud_project(new_project_id)
+                print(f"{Colors.SUCCESS}{Icons.CHECK} Project ID set to: {new_project_id}{Colors.RESET}")
+        elif choice == '4':
+            print(f"{Colors.MUTED}Cancelled.{Colors.RESET}")
+        else:
+            print(f"{Colors.ERROR}Invalid option.{Colors.RESET}")
+        return "continue"
+        
+    elif c.startswith('/show-reasoning'):
+        parts = c.split()
+        if len(parts) > 1:
+            val = parts[1]
+            if val in ['true', 'on', '1', 'yes']:
+                api.SHOW_REASONING = True
+                print(f"{Colors.SUCCESS}{Icons.CHECK} Showing reasoning tokens enabled (session only).{Colors.RESET}")
+            elif val in ['false', 'off', '0', 'no']:
+                api.SHOW_REASONING = False
+                print(f"{Colors.SUCCESS}{Icons.CHECK} Showing reasoning tokens disabled.{Colors.RESET}")
+            else:
+                print(f"{Colors.ERROR}Invalid value: {val}. Use true/false.{Colors.RESET}")
+        else:
+            # Toggle if no value provided
+            api.SHOW_REASONING = not api.SHOW_REASONING
+            status = "enabled" if api.SHOW_REASONING else "disabled"
+            print(f"{Colors.SUCCESS}{Icons.CHECK} Showing reasoning tokens {status}.{Colors.RESET}")
+        return "continue"
+        
+    elif c.startswith('/save'):
+        parts = cmd.split(None, 1)
+        if len(parts) > 1:
+            name = parts[1].strip()
+        else:
+            print(f"\n{Colors.MUTED}Enter a name for this chat:{Colors.RESET}")
+            name = interrupt.safe_input(f"{Colors.INPUT_ACTIVE}> {Colors.RESET}").strip()
+            
+        if not name:
+            print(f"{Colors.ERROR}Chat name required.{Colors.RESET}")
+            return "continue"
+            
+        path = chat_manager.save_chat(name, state['messages'], state['current_model'], api.CURRENT_API)
+        print(f"{Colors.SUCCESS}{Icons.CHECK} Chat saved to {Colors.SECONDARY}{path}{Colors.RESET}\n")
+        return "continue"
+
+    elif c.startswith('/load'):
+        parts = cmd.split(None, 1)
+        if len(parts) > 1:
+            name = parts[1].strip()
+        else:
+            # If no name provided, list chats and let user pick
+            chats = chat_manager.list_chats()
+            if not chats:
+                print(f"{Colors.WARNING}No saved chats found.{Colors.RESET}")
+                return "continue"
+            
+            title = "Select Chat to Load"
+            options = [f"{c['name']} ({Colors.MUTED}{c['model']}{Colors.RESET})" for c in chats]
+            result = ui.select_option(options, title)
+            if not result:
+                return "continue"
+            _, idx = result
+            name = chats[idx]['name']
+            
+        chat_data = chat_manager.load_chat(name)
+        if chat_data:
+            state['messages'] = chat_data['messages']
+            
+            print(f"{Colors.SUCCESS}{Icons.CHECK} Chat '{name}' loaded.{Colors.RESET}\n")
+            os.system('cls' if os.name == 'nt' else 'clear')
+            ui.print_messages(state['messages'])
+            return "continue"
+        else:
+            print(f"{Colors.ERROR}Chat '{name}' not found.{Colors.RESET}")
+            return "continue"
+
+    elif c == '/manage-chats':
+        chat_to_load = chat_manager.manage_chats_ui()
+        if chat_to_load:
+            chat_data = chat_manager.load_chat(chat_to_load)
+            if chat_data:
+                state['messages'] = chat_data['messages']
+                
+                print(f"{Colors.SUCCESS}{Icons.CHECK} Chat '{chat_to_load}' loaded.{Colors.RESET}\n")
+                os.system('cls' if os.name == 'nt' else 'clear')
+                ui.print_messages(state['messages'])
+        return "continue"
+        
+    else:
+        print(f"{Colors.ERROR}Unknown command: {cmd}{Colors.RESET}")
+        print(f"{Colors.MUTED}Type /help for available commands.{Colors.RESET}")
+        return "continue"