chat-console 0.4.7__py3-none-any.whl → 0.4.91__py3-none-any.whl

app/console_chat.py

@@ -11,6 +11,8 @@ import argparse
 import signal
 import threading
 import time
+import random
+import json
 from datetime import datetime
 from typing import List, Optional, Dict, Any
 import shutil
@@ -23,7 +25,7 @@ from .console_utils import console_streaming_response, apply_style_prefix
 from .api.base import BaseModelClient
 
 class ConsoleUI:
-    """Pure console UI following Rams design principles"""
+    """Pure console UI following Rams design principles with Gemini-inspired enhancements"""
     
     def __init__(self):
         self.width = min(shutil.get_terminal_size().columns, 120)
@@ -36,10 +38,49 @@ class ConsoleUI:
         self.running = True
         self.generating = False
         self.input_mode = "text"  # "text" or "menu"
+        self.multi_line_input = []
+        self.input_history = []
+        self.history_index = 0
+        self.theme = self._load_theme()
+        self.loading_phrases = [
+            "Thinking deeply", "Crafting response", "Processing context",
+            "Analyzing request", "Generating ideas", "Considering options",
+            "Formulating answer", "Connecting concepts", "Refining thoughts"
+        ]
+        self.loading_phase_index = 0
+        self.start_time = time.time()
         
         # Suppress verbose logging for console mode
         self._setup_console_logging()
     
+    def _load_theme(self) -> Dict[str, str]:
+        """Load color theme configuration"""
+        try:
+            # Try to import colorama for colors
+            from colorama import Fore, Back, Style, init
+            init(autoreset=True)
+            
+            # Default theme inspired by gemini-code-assist
+            return {
+                'primary': Fore.CYAN,
+                'secondary': Fore.BLUE,
+                'accent': Fore.MAGENTA,
+                'success': Fore.GREEN,
+                'warning': Fore.YELLOW,
+                'error': Fore.RED,
+                'muted': Fore.LIGHTBLACK_EX,
+                'text': Fore.WHITE,
+                'reset': Style.RESET_ALL,
+                'bold': Style.BRIGHT,
+                'dim': Style.DIM
+            }
+        except ImportError:
+            # Fallback to no colors if colorama not available
+            return {key: '' for key in [
+                'primary', 'secondary', 'accent', 'success', 'warning', 
+                'error', 'muted', 'text', 'reset', 'bold', 'dim'
+            ]}
+    
     def _setup_console_logging(self):
         """Setup logging to minimize disruption to console UI"""
         import logging
@@ -132,105 +173,250 @@ class ConsoleUI:
             return chars['horizontal'] * width
     
     def draw_header(self) -> List[str]:
-        """Draw the application header"""
+        """Draw the application header with colors"""
         from . import __version__
         chars = self.get_border_chars()
         
         lines = []
         
         # Top border with title and model info
-        title = f" Chat Console v{__version__} "
-        model_info = f" Model: {self.selected_model} "
+        title = f" {self.theme['primary']}Chat Console{self.theme['reset']} v{__version__} "
+        model_info = f" Model: {self.theme['accent']}{self.selected_model}{self.theme['reset']} "
         
-        # Calculate spacing
-        used_space = len(title) + len(model_info)
+        # Calculate spacing (without color codes for length calculation)
+        title_plain = f" Chat Console v{__version__} "
+        model_plain = f" Model: {self.selected_model} "
+        used_space = len(title_plain) + len(model_plain)
         remaining = self.width - used_space - 2
         spacing = chars['horizontal'] * max(0, remaining)
         
-        header_line = chars['top_left'] + title + spacing + model_info + chars['top_right']
+        header_line = f"{self.theme['muted']}{chars['top_left']}{title}{spacing}{model_info}{chars['top_right']}{self.theme['reset']}"
         lines.append(header_line)
         
         # Conversation title
         conv_title = self.current_conversation.title if self.current_conversation else "New Conversation"
-        title_line = chars['vertical'] + f" {conv_title} ".ljust(self.width - 2) + chars['vertical']
+        title_content = f" {self.theme['secondary']}{conv_title}{self.theme['reset']} "
+        padding_needed = self.width - 2 - len(conv_title) - 1
+        title_line = f"{self.theme['muted']}{chars['vertical']}{title_content}{' ' * padding_needed}{chars['vertical']}{self.theme['reset']}"
         lines.append(title_line)
         
         # Separator
-        lines.append(self.draw_border_line(self.width, 'middle'))
+        separator = f"{self.theme['muted']}{self.draw_border_line(self.width, 'middle')}{self.theme['reset']}"
+        lines.append(separator)
         
         return lines
     
     def draw_footer(self) -> List[str]:
-        """Draw the footer with controls"""
+        """Draw the footer with colorized controls"""
         chars = self.get_border_chars()
         
-        controls = "[Tab] Menu Mode  [q] Quit  [n] New  [h] History  [s] Settings"
-        footer_line = chars['vertical'] + f" {controls} ".ljust(self.width - 2) + chars['vertical']
+        # Colorize control keys
+        controls = (f"{self.theme['accent']}[Tab]{self.theme['reset']} Menu Mode  "
+                   f"{self.theme['accent']}[q]{self.theme['reset']} Quit  "
+                   f"{self.theme['accent']}[n]{self.theme['reset']} New  "
+                   f"{self.theme['accent']}[h]{self.theme['reset']} History  "
+                   f"{self.theme['accent']}[s]{self.theme['reset']} Settings  "
+                   f"{self.theme['accent']}[m]{self.theme['reset']} Models")
+        
+        # Calculate plain text length for padding
+        controls_plain = "[Tab] Menu Mode  [q] Quit  [n] New  [h] History  [s] Settings  [m] Models"
+        padding_needed = self.width - 2 - len(controls_plain) - 1
+        
+        footer_line = f"{self.theme['muted']}{chars['vertical']} {controls}{' ' * padding_needed}{chars['vertical']}{self.theme['reset']}"
         
         return [
-            self.draw_border_line(self.width, 'middle'),
+            f"{self.theme['muted']}{self.draw_border_line(self.width, 'middle')}{self.theme['reset']}",
             footer_line,
-            self.draw_border_line(self.width, 'bottom')
+            f"{self.theme['muted']}{self.draw_border_line(self.width, 'bottom')}{self.theme['reset']}"
         ]
     
     def format_message(self, message: Message) -> List[str]:
-        """Format a message for console display"""
+        """Enhanced message formatting with colors, code highlighting and better wrapping"""
         timestamp = datetime.now().strftime("%H:%M")
         chars = self.get_border_chars()
         
         # Calculate available width for content
         content_width = self.width - 10  # Account for borders and timestamp
         
-        # Word wrap content
-        words = message.content.split()
-        lines = []
-        current_line = ""
-        
-        for word in words:
-            if len(current_line) + len(word) + 1 <= content_width:
-                if current_line:
-                    current_line += " "
-                current_line += word
-            else:
-                if current_line:
-                    lines.append(current_line)
-                current_line = word
+        # Apply code highlighting if enabled
+        highlighted_content = self._detect_and_highlight_code(message.content)
         
-        if current_line:
-            lines.append(current_line)
+        # Use improved word wrapping
+        lines = self._improved_word_wrap(highlighted_content, content_width)
         
-        # Format lines with proper spacing
+        # Format lines with proper spacing and colors
         formatted_lines = []
         for i, line in enumerate(lines):
             if i == 0:
-                # First line with timestamp
-                prefix = f"  {timestamp}  " if message.role == "user" else f"  {timestamp}  "
-                formatted_line = chars['vertical'] + prefix + line.ljust(content_width) + chars['vertical']
+                # First line with colorized timestamp and role indicator
+                if message.role == "user":
+                    role_indicator = f"{self.theme['primary']}👤{self.theme['reset']}"
+                    role_color = self.theme['primary']
+                else:
+                    role_indicator = f"{self.theme['accent']}🤖{self.theme['reset']}"
+                    role_color = self.theme['accent']
+                    
+                prefix = f" {role_indicator} {self.theme['muted']}{timestamp}{self.theme['reset']} "
+                
+                # Calculate plain text length for proper alignment
+                prefix_plain = f" 👤 {timestamp} "
+                content_padding = content_width - len(prefix_plain) - len(line.replace(self.theme.get('accent', ''), '').replace(self.theme.get('reset', ''), ''))
+                
+                formatted_line = f"{self.theme['muted']}{chars['vertical']}{prefix}{line}{' ' * max(0, content_padding)}{chars['vertical']}{self.theme['reset']}"
             else:
-                # Continuation lines
+                # Continuation lines with proper indentation
                 prefix = "        "  # Align with content
-                formatted_line = chars['vertical'] + prefix + line.ljust(content_width) + chars['vertical']
+                content_padding = content_width - len(prefix) - len(line.replace(self.theme.get('accent', ''), '').replace(self.theme.get('reset', ''), ''))
+                formatted_line = f"{self.theme['muted']}{chars['vertical']}{prefix}{line}{' ' * max(0, content_padding)}{chars['vertical']}{self.theme['reset']}"
             formatted_lines.append(formatted_line)
         
         # Add empty line for spacing
-        empty_line = chars['vertical'] + " " * (self.width - 2) + chars['vertical']
+        empty_line = f"{self.theme['muted']}{chars['vertical']}{' ' * (self.width - 2)}{chars['vertical']}{self.theme['reset']}"
         formatted_lines.append(empty_line)
         
         return formatted_lines
     
+    def _detect_and_highlight_code(self, content: str) -> str:
+        """Detect and highlight code blocks in content"""
+        if not CONFIG.get("highlight_code", True):
+            return content
+            
+        try:
+            # Try to import colorama for terminal colors
+            from colorama import Fore, Style, init
+            init()  # Initialize colorama
+            
+            lines = content.split('\n')
+            result_lines = []
+            in_code_block = False
+            
+            for line in lines:
+                # Detect code block markers
+                if line.strip().startswith('```'):
+                    in_code_block = not in_code_block
+                    if in_code_block:
+                        result_lines.append(f"{Fore.CYAN}{line}{Style.RESET_ALL}")
+                    else:
+                        result_lines.append(f"{Fore.CYAN}{line}{Style.RESET_ALL}")
+                elif in_code_block:
+                    # Highlight code content
+                    result_lines.append(f"{Fore.GREEN}{line}{Style.RESET_ALL}")
+                elif '`' in line and line.count('`') >= 2:
+                    # Inline code highlighting
+                    import re
+                    highlighted = re.sub(
+                        r'`([^`]+)`', 
+                        f'{Fore.GREEN}`\\1`{Style.RESET_ALL}', 
+                        line
+                    )
+                    result_lines.append(highlighted)
+                else:
+                    result_lines.append(line)
+            
+            return '\n'.join(result_lines)
+            
+        except ImportError:
+            # Colorama not available, return content as-is
+            return content
+        except Exception:
+            # Any other error, return content as-is
+            return content
+    
+    def _improved_word_wrap(self, text: str, width: int) -> List[str]:
+        """Improved word wrapping that preserves code blocks and handles long lines"""
+        lines = text.split('\n')
+        wrapped_lines = []
+        
+        for line in lines:
+            # Handle very long lines (like URLs or code)
+            if len(line) > width:
+                # If it looks like code or a URL, don't break it aggressively
+                if (line.strip().startswith(('http', 'https', 'www', '  ', '\t')) or 
+                    '```' in line or line.count('`') >= 2):
+                    # Add as-is but truncate if necessary
+                    if len(line) > width:
+                        wrapped_lines.append(line[:width-3] + "...")
+                    else:
+                        wrapped_lines.append(line)
+                else:
+                    # Normal word wrapping
+                    words = line.split()
+                    current_line = ""
+                    
+                    for word in words:
+                        if len(current_line) + len(word) + 1 <= width:
+                            if current_line:
+                                current_line += " "
+                            current_line += word
+                        else:
+                            if current_line:
+                                wrapped_lines.append(current_line)
+                            current_line = word
+                    
+                    if current_line:
+                        wrapped_lines.append(current_line)
+            else:
+                # Line fits, add as-is
+                wrapped_lines.append(line)
+        
+        return wrapped_lines or [""]
+    
+    def draw_ascii_welcome(self) -> List[str]:
+        """Draw ASCII art welcome screen"""
+        chars = self.get_border_chars()
+        lines = []
+        
+        # ASCII art that scales with terminal width
+        if self.width >= 80:
+            ascii_art = [
+                "    ┌─┐┬ ┬┌─┐┌┬┐  ┌─┐┌─┐┌┐┌┌─┐┌─┐┬  ┌─┐",
+                "    │  ├─┤├─┤ │   │  │ ││││└─┐│ ││  ├┤ ",
+                "    └─┘┴ ┴┴ ┴ ┴   └─┘└─┘┘└┘└─┘└─┘┴─┘└─┘"
+            ]
+        elif self.width >= 60:
+            ascii_art = [
+                "  ┌─┐┬ ┬┌─┐┌┬┐",
+                "  │  ├─┤├─┤ │ ",
+                "  └─┘┴ ┴┴ ┴ ┴ "
+            ]
+        else:
+            ascii_art = ["Chat Console"]
+        
+        # Center and colorize ASCII art
+        for art_line in ascii_art:
+            centered = art_line.center(self.width - 2)
+            colored_line = f"{self.theme['muted']}{chars['vertical']} {self.theme['primary']}{centered}{self.theme['muted']} {chars['vertical']}{self.theme['reset']}"
+            lines.append(colored_line)
+        
+        # Add spacing
+        empty_line = f"{self.theme['muted']}{chars['vertical']}{' ' * (self.width - 2)}{chars['vertical']}{self.theme['reset']}"
+        lines.append(empty_line)
+        
+        # Add tips
+        tips = [
+            f"{self.theme['secondary']}💡 Pro Tips:{self.theme['reset']}",
+            f"{self.theme['accent']}• Use Shift+Enter for multi-line input{self.theme['reset']}",
+            f"{self.theme['accent']}• Press Tab to switch between text and menu modes{self.theme['reset']}",
+            f"{self.theme['accent']}• Try 'm' for model browser{self.theme['reset']}"
+        ]
+        
+        for tip in tips:
+            # Calculate plain text length for padding
+            tip_plain = tip.replace(self.theme.get('secondary', ''), '').replace(self.theme.get('accent', ''), '').replace(self.theme.get('reset', ''), '')
+            padding = (self.width - 2 - len(tip_plain)) // 2
+            tip_line = f"{self.theme['muted']}{chars['vertical']}{' ' * padding}{tip}{' ' * (self.width - 2 - len(tip_plain) - padding)}{chars['vertical']}{self.theme['reset']}"
+            lines.append(tip_line)
+        
+        return lines
+
     def draw_messages(self) -> List[str]:
-        """Draw all messages in the conversation"""
+        """Draw all messages in the conversation with enhanced empty state"""
         lines = []
         chars = self.get_border_chars()
         
         if not self.messages:
-            # Empty state
-            empty_line = chars['vertical'] + " " * (self.width - 2) + chars['vertical']
-            lines.extend([empty_line] * 3)
-            center_text = "Start a conversation by typing a message below"
-            centered_line = chars['vertical'] + center_text.center(self.width - 2) + chars['vertical']
-            lines.append(centered_line)
-            lines.extend([empty_line] * 3)
+            # Enhanced empty state with ASCII welcome
+            lines.extend(self.draw_ascii_welcome())
         else:
             # Display messages
             for message in self.messages[-10:]:  # Show last 10 messages
@@ -239,33 +425,64 @@ class ConsoleUI:
         return lines
     
     def draw_input_area(self, current_input: str = "", prompt: str = "Type your message") -> List[str]:
-        """Draw the input area with mode indicator"""
+        """Draw the input area with enhanced multi-line support and indicators"""
         chars = self.get_border_chars()
         lines = []
         
-        # Input prompt with mode indicator
+        # Input prompt with mode indicator and multi-line status
         mode_indicator = "📝" if self.input_mode == "text" else "⚡"
         mode_text = "TEXT" if self.input_mode == "text" else "MENU"
-        prompt_with_mode = f"{mode_indicator} {prompt} ({mode_text} mode - Tab to switch)"
-        prompt_line = chars['vertical'] + f" {prompt_with_mode}: ".ljust(self.width - 2) + chars['vertical']
+        
+        # Multi-line indicator
+        if self.multi_line_input:
+            ml_indicator = f"{self.theme['accent']}[MULTI-LINE: {len(self.multi_line_input)} lines]{self.theme['reset']}"
+            prompt_with_mode = f"{mode_indicator} {ml_indicator} (Ctrl+D to send, Esc to cancel)"
+        else:
+            prompt_with_mode = f"{mode_indicator} {prompt} ({mode_text} mode - Tab to switch, Ctrl+J for multi-line)"
+        
+        prompt_line = chars['vertical'] + f" {prompt_with_mode}".ljust(self.width - 2) + chars['vertical']
         lines.append(prompt_line)
         
-        # Input field
+        # Input field(s)
         if self.input_mode == "text":
-            input_content = current_input
-            if len(input_content) > self.width - 6:
-                input_content = input_content[-(self.width - 9):] + "..."
-            input_line = chars['vertical'] + f" > {input_content}".ljust(self.width - 2) + chars['vertical']
+            if self.multi_line_input:
+                # Show multi-line input with line numbers
+                for i, line_content in enumerate(self.multi_line_input[-3:]):  # Show last 3 lines
+                    line_num = len(self.multi_line_input) - 3 + i + 1 if len(self.multi_line_input) > 3 else i + 1
+                    if len(line_content) > self.width - 12:
+                        display_content = line_content[:self.width - 15] + "..."
+                    else:
+                        display_content = line_content
+                    
+                    if i == len(self.multi_line_input[-3:]) - 1:  # Current line
+                        input_line = chars['vertical'] + f" {self.theme['primary']}{line_num:2d}>{self.theme['reset']} {display_content}".ljust(self.width - 2) + chars['vertical']
+                    else:
+                        input_line = chars['vertical'] + f" {self.theme['muted']}{line_num:2d}:{self.theme['reset']} {display_content}".ljust(self.width - 2) + chars['vertical']
+                    lines.append(input_line)
+                
+                # Show line count if more than 3 lines
+                if len(self.multi_line_input) > 3:
+                    more_line = chars['vertical'] + f" {self.theme['muted']}... ({len(self.multi_line_input)} total lines){self.theme['reset']}".ljust(self.width - 2) + chars['vertical']
+                    lines.append(more_line)
+            else:
+                # Single line input
+                input_content = current_input
+                if len(input_content) > self.width - 6:
+                    input_content = input_content[-(self.width - 9):] + "..."
+                input_line = chars['vertical'] + f" {self.theme['primary']}>{self.theme['reset']} {input_content}".ljust(self.width - 2) + chars['vertical']
+                lines.append(input_line)
         else:
             # Menu mode - show available hotkeys
-            menu_help = "n)ew  h)istory  s)ettings  q)uit"
+            menu_help = f"{self.theme['secondary']}n{self.theme['reset']})ew  {self.theme['secondary']}h{self.theme['reset']})istory  {self.theme['secondary']}s{self.theme['reset']})ettings  {self.theme['secondary']}m{self.theme['reset']})odels  {self.theme['secondary']}q{self.theme['reset']})uit"
             input_line = chars['vertical'] + f" {menu_help}".ljust(self.width - 2) + chars['vertical']
-        
-        lines.append(input_line)
+            lines.append(input_line)
         
         # Show generating indicator if needed
         if self.generating:
-            status_line = chars['vertical'] + " ● Generating response...".ljust(self.width - 2) + chars['vertical']
+            elapsed = int(time.time() - self.start_time) if hasattr(self, 'start_time') else 0
+            user_message = getattr(self, '_current_user_message', "")
+            phrase = self._get_dynamic_loading_phrase(user_message)
+            status_line = chars['vertical'] + f" {self.theme['accent']}● {phrase}... ({elapsed}s){self.theme['reset']}".ljust(self.width - 2) + chars['vertical']
             lines.append(status_line)
         
         return lines
@@ -317,43 +534,87 @@ class ConsoleUI:
         sys.stdout.flush()
     
     def get_input(self, prompt: str = "Type your message") -> str:
-        """Enhanced input with tab navigation and hotkey support"""
-        current_input = ""
+        """Enhanced input with multi-line support, history navigation, and hotkey support"""
+        # Check if we're in multi-line mode
+        if self.multi_line_input:
+            current_input = "\n".join(self.multi_line_input)
+        else:
+            current_input = ""
         
         while True:
-            self.draw_screen(current_input, prompt)
-            
-            # Get single character
-            if os.name == 'nt':
-                import msvcrt
-                char = msvcrt.getch().decode('utf-8', errors='ignore')
+            # Update prompt based on multi-line state
+            if self.multi_line_input:
+                display_prompt = f"Multi-line input (Ctrl+D to send, Esc to cancel)"
             else:
-                import termios, tty
-                fd = sys.stdin.fileno()
-                old_settings = termios.tcgetattr(fd)
-                try:
-                    tty.setraw(sys.stdin.fileno())
-                    char = sys.stdin.read(1)
-                finally:
-                    termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+                display_prompt = prompt
+                
+            # Only redraw screen if not currently generating to avoid interference
+            if not self.generating:
+                self.draw_screen(current_input, display_prompt)
+            
+            # Get character input with escape sequence handling
+            char = self._get_char_with_escape_sequences()
             
-            # Handle special keys first
+            # Handle escape sequences for arrow keys
+            if char.startswith('\x1b['):
+                if char == '\x1b[A':  # Up arrow - history navigation
+                    if self.input_history and self.history_index > 0:
+                        self.history_index -= 1
+                        current_input = self.input_history[self.history_index]
+                        self.multi_line_input = current_input.split('\n') if '\n' in current_input else []
+                elif char == '\x1b[B':  # Down arrow - history navigation
+                    if self.history_index < len(self.input_history) - 1:
+                        self.history_index += 1
+                        current_input = self.input_history[self.history_index]
+                        self.multi_line_input = current_input.split('\n') if '\n' in current_input else []
+                    elif self.history_index == len(self.input_history) - 1:
+                        self.history_index = len(self.input_history)
+                        current_input = ""
+                        self.multi_line_input = []
+                continue
+            
+            # Handle special keys
             if char == '\t':
                 # Tab - switch between text and menu mode
                 self.input_mode = "menu" if self.input_mode == "text" else "text"
                 continue
             elif char == '\r' or char == '\n':
-                # Enter
+                # Enter - either new line (Shift+Enter) or submit
                 if self.input_mode == "text":
-                    # Submit text input
-                    if current_input.strip():
-                        return current_input.strip()
-                    # If empty input in text mode, switch to menu mode
-                    self.input_mode = "menu"
+                    if self.multi_line_input:
+                        # In multi-line mode, add new line
+                        self.multi_line_input.append("")
+                        current_input = "\n".join(self.multi_line_input)
+                    else:
+                        # Check for Shift+Enter to start multi-line
+                        # For simplicity, just Enter submits, Shift+Enter would need platform-specific detection
+                        if current_input.strip():
+                            # Add to history
+                            if current_input not in self.input_history:
+                                self.input_history.append(current_input)
+                            self.history_index = len(self.input_history)
+                            return current_input.strip()
+                        else:
+                            self.input_mode = "menu"
                     continue
                 else:
                     # In menu mode, Enter does nothing
                     continue
+            elif char == '\x04':  # Ctrl+D - send multi-line input
+                if self.multi_line_input and any(line.strip() for line in self.multi_line_input):
+                    final_input = "\n".join(self.multi_line_input).strip()
+                    if final_input not in self.input_history:
+                        self.input_history.append(final_input)
+                    self.history_index = len(self.input_history)
+                    self.multi_line_input = []
+                    return final_input
+            elif char == '\x1b':  # Escape - cancel multi-line or switch to text mode
+                if self.multi_line_input:
+                    self.multi_line_input = []
+                    current_input = ""
+                else:
+                    self.input_mode = "text"
+                continue
             elif char == '\x03':
                 # Ctrl+C
                 if self.generating:
@@ -367,10 +628,30 @@ class ConsoleUI:
                 # Text input mode
                 if char == '\x7f' or char == '\x08':
                     # Backspace
-                    current_input = current_input[:-1]
+                    if self.multi_line_input:
+                        if self.multi_line_input[-1]:
+                            self.multi_line_input[-1] = self.multi_line_input[-1][:-1]
+                        elif len(self.multi_line_input) > 1:
+                            self.multi_line_input.pop()
+                        current_input = "\n".join(self.multi_line_input)
+                    else:
+                        current_input = current_input[:-1]
+                elif char == '\x0a':  # Ctrl+J - start/continue multi-line
+                    if not self.multi_line_input:
+                        # Start multi-line mode
+                        self.multi_line_input = [current_input, ""]
+                        current_input = "\n".join(self.multi_line_input)
+                    else:
+                        # Add new line in multi-line mode
+                        self.multi_line_input.append("")
+                        current_input = "\n".join(self.multi_line_input)
                 elif ord(char) >= 32:
                     # Printable character
-                    current_input += char
+                    if self.multi_line_input:
+                        self.multi_line_input[-1] += char
+                        current_input = "\n".join(self.multi_line_input)
+                    else:
+                        current_input += char
             else:
                 # Menu mode - handle hotkeys
                 if char.lower() == 'q':
@@ -381,10 +662,157 @@ class ConsoleUI:
                     return "##HISTORY##"
                 elif char.lower() == 's':
                     return "##SETTINGS##"
+                elif char.lower() == 'm':
+                    return "##MODELS##"
                 elif char == '\x1b':  # Escape - back to text mode
                     self.input_mode = "text"
                     continue
     
+    def _get_char_with_escape_sequences(self) -> str:
+        """Get character input with support for escape sequences (arrow keys)"""
+        if os.name == 'nt':
+            import msvcrt
+            char = msvcrt.getch()
+            if char == b'\xe0':  # Special key prefix on Windows
+                char = msvcrt.getch()
+                if char == b'H':  # Up arrow
+                    return '\x1b[A'
+                elif char == b'P':  # Down arrow
+                    return '\x1b[B'
+            return char.decode('utf-8', errors='ignore')
+        else:
+            import termios, tty
+            fd = sys.stdin.fileno()
+            old_settings = termios.tcgetattr(fd)
+            try:
+                tty.setraw(sys.stdin.fileno())
+                char = sys.stdin.read(1)
+                if char == '\x1b':  # Escape sequence
+                    char += sys.stdin.read(2)  # Read [A, [B, etc.
+                return char
+            finally:
+                termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+    
+    def _get_context_aware_loading_phrases(self, user_message: str) -> List[str]:
+        """Generate context-aware loading phrases based on user input"""
+        message_lower = user_message.lower()
+        
+        # Code-related keywords
+        if any(keyword in message_lower for keyword in [
+            'code', 'function', 'debug', 'error', 'bug', 'script', 'program', 
+            'algorithm', 'python', 'javascript', 'java', 'c++', 'html', 'css',
+            'sql', 'git', 'api', 'database', 'framework', 'library'
+        ]):
+            return [
+                "Analyzing your code", "Reviewing logic", "Debugging the issue",
+                "Examining patterns", "Processing syntax", "Evaluating approach",
+                "Formulating solution", "Optimizing structure"
+            ]
+        
+        # Writing/creative keywords  
+        elif any(keyword in message_lower for keyword in [
+            'write', 'essay', 'story', 'article', 'blog', 'creative', 'poem',
+            'letter', 'email', 'content', 'draft', 'narrative', 'description'
+        ]):
+            return [
+                "Crafting your text", "Shaping ideas", "Weaving words",
+                "Building narrative", "Polishing prose", "Structuring content",
+                "Refining language", "Creating flow"
+            ]
+        
+        # Analysis/research keywords
+        elif any(keyword in message_lower for keyword in [
+            'analyze', 'research', 'study', 'explain', 'compare', 'evaluate',
+            'assess', 'investigate', 'examine', 'understand', 'interpret'
+        ]):
+            return [
+                "Analyzing information", "Processing data", "Examining details",
+                "Connecting insights", "Evaluating evidence", "Synthesizing findings",
+                "Drawing conclusions", "Structuring analysis"
+            ]
+        
+        # Math/calculation keywords
+        elif any(keyword in message_lower for keyword in [
+            'calculate', 'math', 'solve', 'equation', 'formula', 'statistics',
+            'probability', 'geometry', 'algebra', 'number', 'compute'
+        ]):
+            return [
+                "Calculating result", "Processing numbers", "Solving equation",
+                "Working through math", "Computing values", "Analyzing formula",
+                "Checking calculations", "Verifying solution"
+            ]
+        
+        # Question/help keywords
+        elif any(keyword in message_lower for keyword in [
+            'how', 'what', 'why', 'when', 'where', 'help', 'assist', 'guide',
+            'explain', 'show', 'teach', 'learn', 'understand'
+        ]):
+            return [
+                "Processing your question", "Gathering information", "Organizing thoughts",
+                "Preparing explanation", "Structuring response", "Connecting concepts",
+                "Clarifying details", "Formulating answer"
+            ]
+        
+        # Default generic phrases
+        else:
+            return self.loading_phrases
+    
+    def _get_dynamic_loading_phrase(self, user_message: str = "") -> str:
+        """Get current loading phrase with context-awareness and cycling"""
+        elapsed = time.time() - self.start_time
+        
+        # Get context-aware phrases if user message provided
+        if user_message and hasattr(self, '_current_context_phrases'):
+            phrases = self._current_context_phrases
+        elif user_message:
+            phrases = self._get_context_aware_loading_phrases(user_message)
+            self._current_context_phrases = phrases  # Cache for this generation
+        else:
+            phrases = self.loading_phrases
+        
+        # Change phrase every 2 seconds
+        phrase_index = int(elapsed // 2) % len(phrases)
+        return phrases[phrase_index]
+    
+    def _update_streaming_display(self, content: str):
+        """Update display with real-time streaming content and context-aware status"""
+        if not self.generating:
+            return
+            
+        # Show dynamic loading indicator with cycling phrases
+        elapsed = int(time.time() - self.start_time)
+        user_message = getattr(self, '_current_user_message', "")
+        phrase = self._get_dynamic_loading_phrase(user_message)
+        
+        # Create a streaming preview of content (first/last parts)
+        preview = ""
+        if content:
+            if len(content) <= 100:
+                preview = content.replace('\n', ' ')[:50]
+            else:
+                # Show first 30 chars + ... + last 20 chars
+                start = content[:30].replace('\n', ' ')
+                end = content[-20:].replace('\n', ' ')
+                preview = f"{start}...{end}"
+        
+        # Use cursor positioning to update multiple lines at bottom
+        print(f"\033[s", end="")  # Save cursor position
+        
+        # Update streaming content area (second to last line)
+        if content:
+            print(f"\033[{self.height-1};1H", end="")  # Move to second-to-last row
+            print(f"\033[K", end="")  # Clear line
+            content_line = f"{self.theme['text']}► {preview}{self.theme['reset']}"
+            print(content_line[:self.width-2], end="", flush=True)
+        
+        # Update status line (bottom)
+        print(f"\033[{self.height};1H", end="")  # Move to bottom row
+        print(f"\033[K", end="")  # Clear line
+        status_line = f"{self.theme['accent']}● {phrase}... {self.theme['muted']}({elapsed}s) - {len(content)} chars{self.theme['reset']}"
+        print(status_line, end="", flush=True)
+        
+        print(f"\033[u", end="", flush=True)  # Restore cursor position
+    
     async def create_new_conversation(self):
         """Create a new conversation"""
         title = "New Conversation"
@@ -419,13 +847,19 @@ class ConsoleUI:
                 self.db.update_conversation_title(self.current_conversation.id, new_title)
                 self.current_conversation.title = new_title
                 
-        except Exception as e:
+        except Exception:
             # Silently fail - title generation is not critical
             pass
     
     async def generate_response(self, user_message: str):
-        """Generate AI response"""
+        """Generate AI response with enhanced streaming display"""
         self.generating = True
+        self.start_time = time.time()  # Reset timer for this generation
+        self._current_user_message = user_message  # Store for context-aware loading
+        
+        # Clear any cached context phrases for new generation
+        if hasattr(self, '_current_context_phrases'):
+            delattr(self, '_current_context_phrases')
         
         try:
             # Add user message
@@ -470,8 +904,8 @@ class ConsoleUI:
                 nonlocal full_response
                 full_response = content
                 assistant_message.content = content
-                # Redraw screen periodically
-                self.draw_screen("", "Generating response")
+                # Update screen with streaming content instead of clearing
+                self._update_streaming_display(content)
             
             # Apply style to messages
             styled_messages = apply_style_prefix(api_messages, self.selected_style)
@@ -533,32 +967,38 @@ class ConsoleUI:
             pass
     
     async def show_settings(self):
-        """Show enhanced settings menu with dynamic model detection"""
+        """Show enhanced settings menu with style selection and persistence"""
         while True:
             self.clear_screen()
             print("=" * self.width)
             print("SETTINGS".center(self.width))
             print("=" * self.width)
             
-            print(f"Current Model: {self.selected_model}")
-            print(f"Current Style: {self.selected_style}")
+            print(f"Current Model: {CONFIG['available_models'].get(self.selected_model, {}).get('display_name', self.selected_model)}")
+            print(f"Current Style: {CONFIG['user_styles'].get(self.selected_style, {}).get('name', self.selected_style)}")
             print()
-            
             print("What would you like to change?")
-            print("1. Select Model")
+            print("1. Model")
             print("2. Response Style")
-            print("3. Detect Ollama Models")
+            print("3. Advanced Settings")
+            print("4. Save Settings")
             print("0. Back to Chat")
             
             try:
                 choice = input("\n> ").strip()
                 
                 if choice == "1":
+                    # Model selection
                     await self._select_model()
                 elif choice == "2":
+                    # Style selection
                     self._select_style()
                 elif choice == "3":
-                    await self._detect_ollama_models()
+                    # Advanced settings
+                    await self._show_advanced_settings()
+                elif choice == "4":
+                    # Save settings
+                    self._save_settings()
                 elif choice == "0" or choice == "":
                     break
                     
@@ -600,7 +1040,7 @@ class ConsoleUI:
                                 "display_name": model_id,
                                 "max_tokens": 4096
                             }))
-        except Exception as e:
+        except Exception:
             pass  # Ollama not available
         
         # Display models by provider
@@ -666,6 +1106,263 @@ class ConsoleUI:
         except (ValueError, KeyboardInterrupt):
             pass
     
+    def _save_settings(self):
+        """Save current settings to config file"""
+        try:
+            CONFIG["default_model"] = self.selected_model
+            CONFIG["default_style"] = self.selected_style
+            save_config(CONFIG)
+            print("Settings saved successfully!")
+        except Exception as e:
+            print(f"Error saving settings: {e}")
+        input("Press Enter to continue...")
+    
+    async def _show_advanced_settings(self):
+        """Show advanced settings configuration panel"""
+        while True:
+            self.clear_screen()
+            print("=" * self.width)
+            print("ADVANCED SETTINGS".center(self.width))
+            print("=" * self.width)
+            
+            # Display current advanced settings
+            print("Current Advanced Settings:")
+            print(f"  Code Highlighting: {'On' if CONFIG.get('highlight_code', True) else 'Off'}")
+            print(f"  Dynamic Titles: {'On' if CONFIG.get('generate_dynamic_titles', True) else 'Off'}")
+            print(f"  Model Preloading: {'On' if CONFIG.get('preload_models', True) else 'Off'}")
+            print(f"  Ollama URL: {CONFIG.get('ollama_base_url', 'http://localhost:11434')}")
+            print(f"  Inactive Timeout: {CONFIG.get('ollama_inactive_timeout', 30)} minutes")
+            print()
+            
+            print("What would you like to configure?")
+            print("1. Provider Settings")
+            print("2. UI Settings")
+            print("3. Performance Settings")
+            print("4. Ollama Settings")
+            print("0. Back to Settings")
+            
+            try:
+                choice = input("\n> ").strip()
+                
+                if choice == "1":
+                    await self._configure_provider_settings()
+                elif choice == "2":
+                    await self._configure_ui_settings()
+                elif choice == "3":
+                    await self._configure_performance_settings()
+                elif choice == "4":
+                    await self._configure_ollama_settings()
+                elif choice == "0" or choice == "":
+                    break
+                    
+            except (ValueError, KeyboardInterrupt):
+                break
+    
+    async def _configure_provider_settings(self):
+        """Configure provider-specific settings"""
+        self.clear_screen()
+        print("=" * self.width)
+        print("PROVIDER SETTINGS".center(self.width))
+        print("=" * self.width)
+        
+        print("Current Provider Settings:")
+        print(f"  OpenAI API Key: {'Set' if CONFIG.get('openai_api_key') else 'Not Set'}")
+        print(f"  Anthropic API Key: {'Set' if CONFIG.get('anthropic_api_key') else 'Not Set'}")
+        print(f"  Ollama Base URL: {CONFIG.get('ollama_base_url', 'http://localhost:11434')}")
+        print()
+        
+        print("Options:")
+        print("1. Set OpenAI API Key")
+        print("2. Set Anthropic API Key")
+        print("3. Set Ollama Base URL")
+        print("4. Clear API Keys")
+        print("0. Back")
+        
+        choice = input("\n> ").strip()
+        
+        if choice == "1":
+            key = input("Enter OpenAI API Key (or press Enter to skip): ").strip()
+            if key:
+                CONFIG["openai_api_key"] = key
+                print("OpenAI API Key updated!")
+                
+        elif choice == "2":
+            key = input("Enter Anthropic API Key (or press Enter to skip): ").strip()
+            if key:
+                CONFIG["anthropic_api_key"] = key
+                print("Anthropic API Key updated!")
+                
+        elif choice == "3":
+            url = input(f"Enter Ollama Base URL (current: {CONFIG.get('ollama_base_url', 'http://localhost:11434')}): ").strip()
+            if url:
+                CONFIG["ollama_base_url"] = url
+                print("Ollama Base URL updated!")
+                
+        elif choice == "4":
+            confirm = input("Clear all API keys? (y/N): ").strip().lower()
+            if confirm == 'y':
+                CONFIG.pop("openai_api_key", None)
+                CONFIG.pop("anthropic_api_key", None)
+                print("API keys cleared!")
+        
+        if choice in ["1", "2", "3", "4"]:
+            input("\nPress Enter to continue...")
+    
+    async def _configure_ui_settings(self):
+        """Configure UI and display settings"""
+        self.clear_screen()
+        print("=" * self.width)
+        print("UI SETTINGS".center(self.width))
+        print("=" * self.width)
+        
+        print("Current UI Settings:")
+        print(f"  Code Highlighting: {'On' if CONFIG.get('highlight_code', True) else 'Off'}")
+        print(f"  Emoji Indicators: {'On' if CONFIG.get('use_emoji_indicators', True) else 'Off'}")
+        print(f"  Word Wrapping: {'On' if CONFIG.get('word_wrap', True) else 'Off'}")
+        print()
+        
+        print("Options:")
+        print("1. Toggle Code Highlighting")
+        print("2. Toggle Emoji Indicators")
+        print("3. Toggle Word Wrapping")
+        print("0. Back")
+        
+        choice = input("\n> ").strip()
+        
+        if choice == "1":
+            current = CONFIG.get('highlight_code', True)
+            CONFIG['highlight_code'] = not current
+            print(f"Code highlighting {'enabled' if not current else 'disabled'}!")
+            
+        elif choice == "2":
+            current = CONFIG.get('use_emoji_indicators', True)
+            CONFIG['use_emoji_indicators'] = not current
+            print(f"Emoji indicators {'enabled' if not current else 'disabled'}!")
+            
+        elif choice == "3":
+            current = CONFIG.get('word_wrap', True)
+            CONFIG['word_wrap'] = not current
+            print(f"Word wrapping {'enabled' if not current else 'disabled'}!")
+        
+        if choice in ["1", "2", "3"]:
+            input("\nPress Enter to continue...")
+    
+    async def _configure_performance_settings(self):
+        """Configure performance and optimization settings"""
+        self.clear_screen()
+        print("=" * self.width)
+        print("PERFORMANCE SETTINGS".center(self.width))
+        print("=" * self.width)
+        
+        print("Current Performance Settings:")
+        print(f"  Dynamic Title Generation: {'On' if CONFIG.get('generate_dynamic_titles', True) else 'Off'}")
+        print(f"  Model Preloading: {'On' if CONFIG.get('preload_models', True) else 'Off'}")
+        print(f"  History Limit: {CONFIG.get('history_limit', 100)} conversations")
+        print(f"  Message Limit: {CONFIG.get('message_limit', 50)} per conversation")
+        print()
+        
+        print("Options:")
+        print("1. Toggle Dynamic Title Generation")
+        print("2. Toggle Model Preloading")
+        print("3. Set History Limit")
+        print("4. Set Message Limit")
+        print("0. Back")
+        
+        choice = input("\n> ").strip()
+        
+        if choice == "1":
+            current = CONFIG.get('generate_dynamic_titles', True)
+            CONFIG['generate_dynamic_titles'] = not current
+            print(f"Dynamic title generation {'enabled' if not current else 'disabled'}!")
+            
+        elif choice == "2":
+            current = CONFIG.get('preload_models', True)
+            CONFIG['preload_models'] = not current
+            print(f"Model preloading {'enabled' if not current else 'disabled'}!")
+            
+        elif choice == "3":
+            try:
+                limit = int(input(f"Enter history limit (current: {CONFIG.get('history_limit', 100)}): "))
+                if limit > 0:
+                    CONFIG['history_limit'] = limit
+                    print(f"History limit set to {limit}!")
+            except ValueError:
+                print("Invalid number!")
+                
+        elif choice == "4":
+            try:
+                limit = int(input(f"Enter message limit (current: {CONFIG.get('message_limit', 50)}): "))
+                if limit > 0:
+                    CONFIG['message_limit'] = limit
+                    print(f"Message limit set to {limit}!")
+            except ValueError:
+                print("Invalid number!")
+        
+        if choice in ["1", "2", "3", "4"]:
+            input("\nPress Enter to continue...")
+    
+    async def _configure_ollama_settings(self):
+        """Configure Ollama-specific settings"""
+        self.clear_screen()
+        print("=" * self.width)
+        print("OLLAMA SETTINGS".center(self.width))
+        print("=" * self.width)
+        
+        print("Current Ollama Settings:")
+        print(f"  Base URL: {CONFIG.get('ollama_base_url', 'http://localhost:11434')}")
+        print(f"  Inactive Timeout: {CONFIG.get('ollama_inactive_timeout', 30)} minutes")
+        print(f"  Auto Start: {'On' if CONFIG.get('ollama_auto_start', True) else 'Off'}")
+        print(f"  Model Cleanup: {'On' if CONFIG.get('ollama_cleanup_models', True) else 'Off'}")
+        print()
+        
+        print("Options:")
+        print("1. Set Base URL")
+        print("2. Set Inactive Timeout")
+        print("3. Toggle Auto Start")
+        print("4. Toggle Model Cleanup")
+        print("5. Test Connection")
+        print("0. Back")
+        
+        choice = input("\n> ").strip()
+        
+        if choice == "1":
+            url = input(f"Enter Ollama Base URL (current: {CONFIG.get('ollama_base_url', 'http://localhost:11434')}): ").strip()
+            if url:
+                CONFIG['ollama_base_url'] = url
+                print("Ollama Base URL updated!")
+                
+        elif choice == "2":
+            try:
+                timeout = int(input(f"Enter inactive timeout in minutes (current: {CONFIG.get('ollama_inactive_timeout', 30)}): "))
+                if timeout > 0:
+                    CONFIG['ollama_inactive_timeout'] = timeout
+                    print(f"Inactive timeout set to {timeout} minutes!")
+            except ValueError:
+                print("Invalid number!")
+                
+        elif choice == "3":
+            current = CONFIG.get('ollama_auto_start', True)
+            CONFIG['ollama_auto_start'] = not current
+            print(f"Ollama auto start {'enabled' if not current else 'disabled'}!")
+            
+        elif choice == "4":
+            current = CONFIG.get('ollama_cleanup_models', True)
+            CONFIG['ollama_cleanup_models'] = not current
+            print(f"Model cleanup {'enabled' if not current else 'disabled'}!")
+            
+        elif choice == "5":
+            print("Testing Ollama connection...")
+            try:
+                from .api.ollama import OllamaClient
+                client = await OllamaClient.create()
+                models = await client.get_available_models()
+                print(f"✓ Connection successful! Found {len(models)} local models.")
+            except Exception as e:
+                print(f"✗ Connection failed: {str(e)}")
+        
+        if choice in ["1", "2", "3", "4", "5"]:
+            input("\nPress Enter to continue...")
+    
     async def _detect_ollama_models(self):
         """Detect and add locally available Ollama models"""
         self.clear_screen()
@@ -714,6 +1411,376 @@ class ConsoleUI:
         
         input("\nPress Enter to continue...")
     
+    async def show_model_browser(self):
+        """Show Ollama model browser for managing local and available models"""
+        while True:
+            self.clear_screen()
+            print("=" * self.width)
+            print("OLLAMA MODEL BROWSER".center(self.width))
+            print("=" * self.width)
+            
+            print("What would you like to do?")
+            print("1. View Local Models")
+            print("2. Browse Available Models")
+            print("3. Search Models")
+            print("4. Switch Current Model")
+            print("0. Back to Chat")
+            
+            try:
+                choice = input("\n> ").strip()
+                
+                if choice == "1":
+                    await self._list_local_models()
+                elif choice == "2":
+                    await self._list_available_models()
+                elif choice == "3":
+                    await self._search_models()
+                elif choice == "4":
+                    await self._switch_model()
+                elif choice == "0" or choice == "":
+                    break
+                    
+            except (ValueError, KeyboardInterrupt):
+                break
+    
+    async def _list_local_models(self):
+        """List locally installed Ollama models"""
+        self.clear_screen()
+        print("=" * self.width)
+        print("LOCAL OLLAMA MODELS".center(self.width))
+        print("=" * self.width)
+        
+        try:
+            # Get Ollama client with output suppression
+            with self._suppress_output():
+                from .api.ollama import OllamaClient
+                client = await OllamaClient.create()
+                
+                # Get local models
+                local_models = await client.get_available_models()
+            
+            if not local_models:
+                print("No local models found.")
+                print("Use option 2 to browse and download models from the registry.")
+            else:
+                print(f"Found {len(local_models)} local models:\n")
+                
+                for i, model in enumerate(local_models):
+                    model_id = model.get("id", "unknown")
+                    marker = "►" if model_id == self.selected_model else " "
+                    print(f"{marker} {i+1:2d}. {model_id}")
+                
+                print("\nOptions:")
+                print("d) Delete a model")
+                print("i) Show model details")
+                print("s) Switch to a model")
+                print("Enter) Back to model browser")
+                
+                sub_choice = input("\n> ").strip().lower()
+                
+                if sub_choice == "d":
+                    await self._delete_model_menu(local_models)
+                elif sub_choice == "i":
+                    await self._show_model_details_menu(local_models)
+                elif sub_choice == "s":
+                    await self._switch_model_menu(local_models)
+                    
+        except Exception as e:
+            print(f"Error connecting to Ollama: {str(e)}")
+            print("Make sure Ollama is running and accessible.")
+            
+        input("\nPress Enter to continue...")
+    
+    async def _list_available_models(self):
+        """List available models for download from Ollama registry"""
+        self.clear_screen()
+        print("=" * self.width)
+        print("AVAILABLE OLLAMA MODELS".center(self.width))
+        print("=" * self.width)
+        
+        try:
+            # Get Ollama client with output suppression
+            with self._suppress_output():
+                from .api.ollama import OllamaClient
+                client = await OllamaClient.create()
+            
+            print("Loading available models... (this may take a moment)")
+            with self._suppress_output():
+                available_models = await client.list_available_models_from_registry("")
+            
+            if not available_models:
+                print("No models found in registry.")
+            else:
+                # Group by model family for better organization
+                families = {}
+                for model in available_models:
+                    family = model.get("model_family", "Other")
+                    if family not in families:
+                        families[family] = []
+                    families[family].append(model)
+                
+                # Display by family
+                model_index = 1
+                model_map = {}
+                
+                for family, models in sorted(families.items()):
+                    print(f"\n{family} Models:")
+                    print("-" * 40)
+                    
+                    for model in models[:5]:  # Show first 5 per family
+                        name = model.get("name", "unknown")
+                        description = model.get("description", "")
+                        size = model.get("parameter_size", "Unknown size")
+                        
+                        print(f"{model_index:2d}. {name} ({size})")
+                        if description:
+                            print(f"    {description[:60]}...")
+                        
+                        model_map[str(model_index)] = model
+                        model_index += 1
+                    
+                    if len(models) > 5:
+                        print(f"    ... and {len(models) - 5} more {family} models")
+                
+                print(f"\nShowing top models by family (total: {len(available_models)})")
+                print("\nOptions:")
+                print("Enter model number to download")
+                print("s) Search for specific models")
+                print("Enter) Back to model browser")
+                
+                choice = input("\n> ").strip()
+                
+                if choice in model_map:
+                    await self._download_model(model_map[choice])
+                elif choice.lower() == "s":
+                    await self._search_models()
+                    
+        except Exception as e:
+            print(f"Error fetching available models: {str(e)}")
+            
+        input("\nPress Enter to continue...")
+    
+    async def _search_models(self):
+        """Search for models by name or description"""
+        self.clear_screen()
+        print("=" * self.width)
+        print("SEARCH OLLAMA MODELS".center(self.width))
+        print("=" * self.width)
+        
+        query = input("Enter search term (name, family, or description): ").strip()
+        
+        if not query:
+            return
+            
+        try:
+            # Get Ollama client with output suppression
+            with self._suppress_output():
+                from .api.ollama import OllamaClient
+                client = await OllamaClient.create()
+            
+            print(f"\nSearching for '{query}'...")
+            with self._suppress_output():
+                all_models = await client.list_available_models_from_registry("")
+            
+            # Filter models
+            matching_models = []
+            query_lower = query.lower()
+            
+            for model in all_models:
+                if (query_lower in model.get("name", "").lower() or
+                    query_lower in model.get("description", "").lower() or
+                    query_lower in model.get("model_family", "").lower()):
+                    matching_models.append(model)
+            
+            if not matching_models:
+                print(f"No models found matching '{query}'")
+            else:
+                print(f"\nFound {len(matching_models)} models matching '{query}':\n")
+                
+                model_map = {}
+                for i, model in enumerate(matching_models[:20]):  # Show first 20 matches
+                    name = model.get("name", "unknown")
+                    description = model.get("description", "")
+                    size = model.get("parameter_size", "Unknown size")
+                    family = model.get("model_family", "Unknown")
+                    
+                    print(f"{i+1:2d}. {name} ({family}, {size})")
+                    if description:
+                        print(f"    {description[:70]}...")
+                    print()
+                    
+                    model_map[str(i+1)] = model
+                
+                if len(matching_models) > 20:
+                    print(f"... and {len(matching_models) - 20} more matches")
+                
+                print("\nEnter model number to download (or press Enter to continue):")
+                choice = input("> ").strip()
+                
+                if choice in model_map:
+                    await self._download_model(model_map[choice])
+                    
+        except Exception as e:
+            print(f"Error searching models: {str(e)}")
+            
+        input("\nPress Enter to continue...")
+    
+    async def _download_model(self, model_info):
+        """Download a model with progress indication"""
+        model_name = model_info.get("name", "unknown")
+        size_info = model_info.get("parameter_size", "Unknown size")
+        
+        print(f"\nDownloading {model_name} ({size_info})...")
+        print("This may take several minutes depending on model size and connection.")
+        print("Press Ctrl+C to cancel.\n")
+        
+        confirm = input(f"Download {model_name}? (y/N): ").strip().lower()
+        if confirm != 'y':
+            return
+            
+        try:
+            # Get Ollama client with output suppression
+            with self._suppress_output():
+                from .api.ollama import OllamaClient
+                client = await OllamaClient.create()
+            
+            # Track download progress
+            last_status = ""
+            
+            async for progress in client.pull_model(model_name):
+                status = progress.get("status", "")
+                
+                if status != last_status:
+                    print(f"Status: {status}")
+                    last_status = status
+                
+                # Show progress if available
+                if "total" in progress and "completed" in progress:
+                    total = progress["total"]
+                    completed = progress["completed"]
+                    percent = (completed / total) * 100 if total > 0 else 0
+                    print(f"Progress: {percent:.1f}% ({completed:,}/{total:,} bytes)")
+                
+                # Check if download is complete
+                if status == "success" or "success" in status.lower():
+                    print(f"\n✓ {model_name} downloaded successfully!")
+                    break
+                    
+        except KeyboardInterrupt:
+            print("\nDownload cancelled by user.")
+        except Exception as e:
+            print(f"\nError downloading model: {str(e)}")
+    
+    async def _delete_model_menu(self, local_models):
+        """Show model deletion menu"""
+        print("\nSelect model to delete:")
+        for i, model in enumerate(local_models):
+            print(f"{i+1:2d}. {model.get('id', 'unknown')}")
+            
+        choice = input("\nEnter model number (or press Enter to cancel): ").strip()
+        
+        if choice.isdigit():
+            idx = int(choice) - 1
+            if 0 <= idx < len(local_models):
+                model_id = local_models[idx].get("id", "unknown")
+                
+                print(f"\nWARNING: This will permanently delete {model_id}")
+                confirm = input("Type 'DELETE' to confirm: ").strip()
+                
+                if confirm == "DELETE":
+                    try:
+                        with self._suppress_output():
+                            from .api.ollama import OllamaClient
+                            client = await OllamaClient.create()
+                            await client.delete_model(model_id)
+                        print(f"✓ {model_id} deleted successfully!")
+                    except Exception as e:
+                        print(f"Error deleting model: {str(e)}")
+                else:
+                    print("Deletion cancelled.")
+    
+    async def _show_model_details_menu(self, local_models):
+        """Show detailed information about a model"""
+        print("\nSelect model for details:")
+        for i, model in enumerate(local_models):
+            print(f"{i+1:2d}. {model.get('id', 'unknown')}")
+            
+        choice = input("\nEnter model number (or press Enter to cancel): ").strip()
+        
+        if choice.isdigit():
+            idx = int(choice) - 1
+            if 0 <= idx < len(local_models):
+                model_id = local_models[idx].get("id", "unknown")
+                await self._show_model_details(model_id)
+    
+    async def _show_model_details(self, model_id):
+        """Show detailed information about a specific model"""
+        try:
+            from .api.ollama import OllamaClient
+            client = await OllamaClient.create()
+            details = await client.get_model_details(model_id)
+            
+            self.clear_screen()
+            print("=" * self.width)
+            print(f"MODEL DETAILS: {model_id}".center(self.width))
+            print("=" * self.width)
+            
+            if "error" in details:
+                print(f"Error getting details: {details['error']}")
+            else:
+                print(f"Name: {model_id}")
+                
+                if details.get("size"):
+                    size_gb = details["size"] / (1024**3)
+                    print(f"Size: {size_gb:.1f} GB")
+                
+                if details.get("modified_at"):
+                    print(f"Modified: {details['modified_at']}")
+                
+                if details.get("parameters"):
+                    print(f"\nParameters: {details['parameters']}")
+                
+                if details.get("modelfile"):
+                    print(f"\nModelfile (first 500 chars):")
+                    print("-" * 40)
+                    print(details["modelfile"][:500])
+                    if len(details["modelfile"]) > 500:
+                        print("...")
+                
+        except Exception as e:
+            print(f"Error getting model details: {str(e)}")
+            
+        input("\nPress Enter to continue...")
+    
+    async def _switch_model_menu(self, local_models):
+        """Switch to a different local model"""
+        print("\nSelect model to switch to:")
+        for i, model in enumerate(local_models):
+            model_id = model.get("id", "unknown")
+            marker = "►" if model_id == self.selected_model else " "
+            print(f"{marker} {i+1:2d}. {model_id}")
+            
+        choice = input("\nEnter model number (or press Enter to cancel): ").strip()
+        
+        if choice.isdigit():
+            idx = int(choice) - 1
+            if 0 <= idx < len(local_models):
+                old_model = self.selected_model
+                self.selected_model = local_models[idx].get("id", "unknown")
+                print(f"\n✓ Switched from {old_model} to {self.selected_model}")
+    
+    async def _switch_model(self):
+        """Switch current model (combines local and available models)"""
+        try:
+            from .api.ollama import OllamaClient
+            client = await OllamaClient.create()
+            local_models = await client.get_available_models()
+            await self._switch_model_menu(local_models)
+        except Exception as e:
+            print(f"Error getting local models: {str(e)}")
+            
+        input("\nPress Enter to continue...")
+    
     async def run(self):
         """Main application loop"""
         # Create initial conversation
@@ -742,6 +1809,9 @@ class ConsoleUI:
                 elif user_input == "##SETTINGS##":
                     await self.show_settings()
                     continue
+                elif user_input == "##MODELS##":
+                    await self.show_model_browser()
+                    continue
                 
                 # Handle legacy single-letter commands for backward compatibility
                 if user_input.lower() == 'q':
@@ -756,6 +1826,9 @@ class ConsoleUI:
                 elif user_input.lower() == 's':
                     await self.show_settings()
                     continue
+                elif user_input.lower() == 'm':
+                    await self.show_model_browser()
+                    continue
                 
                 # Generate response
                 await self.generate_response(user_input)
@@ -774,7 +1847,7 @@ class ConsoleUI:
 
 def setup_signal_handlers():
     """Setup signal handlers for graceful shutdown"""
-    def signal_handler(signum, frame):
+    def signal_handler(_signum, _frame):
         print("\n\nShutting down gracefully...")
         sys.exit(0)