cortex-llm 1.0.9__py3-none-any.whl → 1.0.11__py3-none-any.whl

cortex/ui/cli.py

@@ -6,19 +6,13 @@ import signal
 import shutil
 import readline
 import time
-import threading
 import logging
-import termios
-import tty
-import getpass
-from typing import Optional, List, Tuple
+from typing import Optional, List
 from datetime import datetime
 from pathlib import Path
-from textwrap import wrap
 
 from rich.live import Live
 from rich.style import Style
-from rich.text import Text
 
 
 logger = logging.getLogger(__name__)
@@ -34,6 +28,14 @@ from cortex.fine_tuning import FineTuneWizard
 from cortex.tools import ToolRunner
 from cortex.tools import protocol as tool_protocol
 from cortex.ui.markdown_render import ThinkMarkdown, PrefixedRenderable, render_plain_with_think
+from cortex.ui import box_rendering
+from cortex.ui.cli_commands import CommandHandlers, handle_command as dispatch_command
+from cortex.ui.cli_prompt import format_prompt_with_chat_template
+from cortex.ui.tool_activity import print_tool_activity
+from cortex.ui import help_ui
+from cortex.ui import model_ui
+from cortex.ui import status_ui
+from cortex.ui.input_box import prompt_input_box
 
 
 class CortexCLI:
@@ -152,75 +154,12 @@ class CortexCLI:
         conversation = self.conversation_manager.get_current_conversation()
         if conversation is None:
             conversation = self.conversation_manager.new_conversation()
-        marker = "[CORTEX_TOOL_INSTRUCTIONS v2]"
+        marker = "[CORTEX_TOOL_INSTRUCTIONS v3]"
         for message in conversation.messages:
             if message.role == MessageRole.SYSTEM and marker in message.content:
                 return
         self.conversation_manager.add_message(MessageRole.SYSTEM, self.tool_runner.tool_instructions())
 
-    def _summarize_tool_call(self, call: dict) -> str:
-        name = str(call.get("name", "tool"))
-        args = call.get("arguments") or {}
-        parts = []
-        preferred = ("path", "query", "anchor", "start_line", "end_line", "recursive", "max_results")
-        for key in preferred:
-            if key in args:
-                value = args[key]
-                if isinstance(value, str) and len(value) > 60:
-                    value = value[:57] + "..."
-                parts.append(f"{key}={value!r}")
-        if not parts and args:
-            for key in list(args.keys())[:3]:
-                value = args[key]
-                if isinstance(value, str) and len(value) > 60:
-                    value = value[:57] + "..."
-                parts.append(f"{key}={value!r}")
-        arg_str = ", ".join(parts)
-        return f"{name}({arg_str})" if arg_str else f"{name}()"
-
-    def _summarize_tool_result(self, result: dict) -> str:
-        name = str(result.get("name", "tool"))
-        if not result.get("ok", False):
-            error = result.get("error") or "unknown error"
-            return f"{name} -> error: {error}"
-        payload = result.get("result") or {}
-        if name == "list_dir":
-            entries = payload.get("entries") or []
-            return f"{name} -> entries={len(entries)}"
-        if name == "search":
-            matches = payload.get("results") or []
-            return f"{name} -> results={len(matches)}"
-        if name == "read_file":
-            path = payload.get("path") or ""
-            start = payload.get("start_line")
-            end = payload.get("end_line")
-            if start and end:
-                return f"{name} -> {path} lines {start}-{end}"
-            if start:
-                return f"{name} -> {path} from line {start}"
-            return f"{name} -> {path}"
-        if name in {"write_file", "create_file", "delete_file", "replace_in_file", "insert_after", "insert_before"}:
-            path = payload.get("path") or ""
-            return f"{name} -> {path}"
-        return f"{name} -> ok"
-
-    def _print_tool_activity(self, tool_calls: list, tool_results: list) -> None:
-        lines = []
-        for call, result in zip(tool_calls, tool_results):
-            lines.append(f"tool {self._summarize_tool_call(call)} -> {self._summarize_tool_result(result)}")
-        if not lines:
-            return
-        text = Text("\n".join(lines), style=Style(color="bright_black", italic=True))
-        renderable = PrefixedRenderable(text, prefix="  ", prefix_style=Style(dim=True), indent="  ", auto_space=False)
-        original_console_width = self.console._width
-        target_width = max(40, int(self.get_terminal_width() * 0.75))
-        self.console.width = target_width
-        try:
-            self.console.print(renderable, highlight=False, soft_wrap=True)
-            self.console.print()
-        finally:
-            self.console._width = original_console_width
-    
     
     def get_terminal_width(self) -> int:
         """Get terminal width."""
@@ -232,95 +171,35 @@ class CortexCLI:
     
     def get_visible_length(self, text: str) -> int:
         """Get visible length of text, ignoring ANSI escape codes and accounting for wide characters."""
-        import re
-        import unicodedata
-        
-        # Remove ANSI escape sequences
-        ansi_escape = re.compile(r'\x1b\[[0-9;]*m')
-        visible_text = ansi_escape.sub('', text)
-        
-        # Calculate display width accounting for wide/ambiguous characters
-        display_width = 0
-        for char in visible_text:
-            width = unicodedata.east_asian_width(char)
-            if width in ('W', 'F'):  # Wide or Fullwidth - always 2 columns
-                display_width += 2
-            elif width == 'A' and char in '●○':  # Ambiguous - might be 2 in some terminals
-                # For now, treat these as single-width since most Western terminals do
-                # But if alignment issues appear with these characters, change to += 2
-                display_width += 1
-            else:
-                display_width += 1
-        
-        return display_width
+        return box_rendering.get_visible_length(text)
     
     def print_box_line(self, content: str, width: int, align: str = 'left'):
         """Print a single line in a box with proper padding."""
-        visible_len = self.get_visible_length(content)
-        padding = width - visible_len - 2  # -2 for the borders
-        
-        if align == 'center':
-            left_pad = padding // 2
-            right_pad = padding - left_pad
-            print(f"│{' ' * left_pad}{content}{' ' * right_pad}│")
-        else:  # left align
-            print(f"│{content}{' ' * padding}│")
+        box_rendering.print_box_line(content, width, align=align)
     
     def print_box_header(self, title: str, width: int):
         """Print a box header with title."""
-        if title:
-            title_with_color = f" \033[96m{title}\033[0m "
-            visible_len = self.get_visible_length(title_with_color)
-            padding = width - visible_len - 3  # -3 for "╭─" and "╮"
-            print(f"╭─{title_with_color}" + "─" * padding + "╮")
-        else:
-            print("╭" + "─" * (width - 2) + "╮")
+        box_rendering.print_box_header(title, width)
     
     def print_box_footer(self, width: int):
         """Print a box footer."""
-        print("╰" + "─" * (width - 2) + "╯")
+        box_rendering.print_box_footer(width)
     
     def print_box_separator(self, width: int):
         """Print a separator line inside a box."""
-        # Width already includes space for borders, so we need exact width-2 for the line
-        print("├" + "─" * (width - 2) + "┤")
+        box_rendering.print_box_separator(width)
     
     def print_empty_line(self, width: int):
         """Print an empty line inside a box."""
-        print("│" + " " * (width - 2) + "│")
+        box_rendering.print_empty_line(width)
     
     def create_box(self, lines: List[str], width: Optional[int] = None) -> str:
         """Create a box with Unicode borders."""
-        if width is None:
-            width = min(self.get_terminal_width() - 2, 80)
-        
-        # Box drawing characters
-        top_left = "╭"
-        top_right = "╮"
-        bottom_left = "╰"
-        bottom_right = "╯"
-        horizontal = "─"
-        vertical = "│"
-        
-        # Calculate inner width
-        inner_width = width - 4  # Account for borders and padding
-        
-        # Build box
-        result = []
-        result.append(top_left + horizontal * (width - 2) + top_right)
-        
-        for line in lines:
-            # Calculate visible length to handle ANSI codes
-            visible_len = self.get_visible_length(line)
-            # Calculate padding needed
-            padding_needed = inner_width - visible_len
-            # Create padded line with correct spacing
-            padded = f" {line}{' ' * padding_needed} "
-            result.append(vertical + padded + vertical)
-        
-        result.append(bottom_left + horizontal * (width - 2) + bottom_right)
-        
-        return "\n".join(result)
+        return box_rendering.create_box(
+            lines,
+            width=width,
+            terminal_width=self.get_terminal_width(),
+        )
     
     def print_welcome(self):
         """Print welcome message in Claude Code style."""
@@ -480,543 +359,48 @@ class CortexCLI:
     
     def handle_command(self, command: str) -> bool:
         """Handle slash commands. Returns False to exit."""
-        parts = command.split(maxsplit=1)
-        cmd = parts[0].lower()
-        args = parts[1] if len(parts) > 1 else ""
-        
-        if cmd == "/help":
-            self.show_help()
-        elif cmd == "/model":
-            self.manage_models(args)
-        elif cmd == "/download":
-            self.download_model(args)
-        elif cmd == "/clear":
-            self.clear_conversation()
-        elif cmd == "/save":
-            self.save_conversation()
-        elif cmd == "/status":
-            self.show_status()
-        elif cmd == "/gpu":
-            self.show_gpu_status()
-        elif cmd == "/benchmark":
-            self.run_benchmark()
-        elif cmd == "/template":
-            self.manage_template(args)
-        elif cmd == "/finetune":
-            self.run_finetune()
-        elif cmd == "/login":
-            self.hf_login()
-        elif cmd in ["/quit", "/exit"]:
-            return False
-        elif cmd == "?":
-            self.show_shortcuts()
-        else:
-            print(f"\033[31mUnknown command: {cmd}\033[0m")
-            print("\033[2mType /help for available commands\033[0m")
-        
-        return True
+        handlers = CommandHandlers(
+            show_help=self.show_help,
+            manage_models=self.manage_models,
+            download_model=self.download_model,
+            clear_conversation=self.clear_conversation,
+            save_conversation=self.save_conversation,
+            show_status=self.show_status,
+            show_gpu_status=self.show_gpu_status,
+            run_benchmark=self.run_benchmark,
+            manage_template=self.manage_template,
+            run_finetune=self.run_finetune,
+            hf_login=self.hf_login,
+            show_shortcuts=self.show_shortcuts,
+        )
+        return dispatch_command(command, handlers)
     
     def show_shortcuts(self):
         """Show keyboard shortcuts."""
-        width = min(self.get_terminal_width() - 2, 70)
-        
-        print()
-        self.print_box_header("Keyboard Shortcuts", width)
-        self.print_empty_line(width)
-        
-        shortcuts = [
-            ("Ctrl+C", "Cancel current generation"),
-            ("Ctrl+D", "Exit Cortex"),
-            ("Tab", "Auto-complete commands"),
-            ("/help", "Show all commands"),
-            ("?", "Show this help")
-        ]
-        
-        for key, desc in shortcuts:
-            # Color the key/command in yellow
-            colored_key = f"\033[93m{key}\033[0m"
-            # Calculate padding
-            key_width = len(key)
-            padding = " " * (12 - key_width)  # Align descriptions at column 14
-            line = f"  {colored_key}{padding}{desc}"
-            self.print_box_line(line, width)
-        
-        self.print_empty_line(width)
-        self.print_box_footer(width)
+        help_ui.show_shortcuts(
+            terminal_width=self.get_terminal_width(),
+            box=self,
+        )
     
     def show_help(self):
         """Show available commands."""
-        width = min(self.get_terminal_width() - 2, 70)
-        
-        print()
-        self.print_box_header("Available Commands", width)
-        self.print_empty_line(width)
-        
-        commands = [
-            ("/help", "Show this help message"),
-            ("/status", "Show current setup and GPU info"),
-            ("/download", "Download a model from HuggingFace"),
-            ("/model", "Manage models (load/delete/info)"),
-            ("/finetune", "Fine-tune a model interactively"),
-            ("/clear", "Clear conversation history"),
-            ("/save", "Save current conversation"),
-            ("/template", "Manage chat templates"),
-            ("/gpu", "Show GPU status"),
-            ("/benchmark", "Run performance benchmark"),
-            ("/login", "Login to HuggingFace for gated models"),
-            ("/quit", "Exit Cortex")
-        ]
-        
-        for cmd, desc in commands:
-            # Format: "  /command    description"
-            # Color the command in yellow
-            colored_cmd = f"\033[93m{cmd}\033[0m"
-            # Calculate padding between command and description
-            cmd_width = len(cmd)
-            padding = " " * (12 - cmd_width)  # Align descriptions at column 14
-            line = f"  {colored_cmd}{padding}{desc}"
-            self.print_box_line(line, width)
-        
-        self.print_empty_line(width)
-        self.print_box_footer(width)
+        help_ui.show_help(
+            terminal_width=self.get_terminal_width(),
+            box=self,
+        )
     
     def download_model(self, args: str = ""):
         """Download a model from HuggingFace."""
-        if args:
-            # Direct download with provided args
-            parts = args.split()
-            repo_id = parts[0]
-            filename = parts[1] if len(parts) > 1 else None
-        else:
-            # Interactive mode with numbered options
-            width = min(self.get_terminal_width() - 2, 70)
-            
-            # Create download UI box using helper methods
-            print()
-            self.print_box_header("Model Manager", width)
-            self.print_empty_line(width)
-            
-            option_num = 1
-            available = self.model_manager.discover_available_models()
-            
-            # Show already downloaded models with numbers to load
-            if available:
-                self.print_box_line("  \033[96mLoad Existing Model:\033[0m", width)
-                self.print_empty_line(width)
-                
-                for model in available[:5]:  # Show up to 5 downloaded models
-                    name = model['name'][:width-15]
-                    size = f"{model['size_gb']:.1f}GB"
-                    line = f"    \033[93m[{option_num}]\033[0m {name} \033[2m({size})\033[0m"
-                    self.print_box_line(line, width)
-                    option_num += 1
-                
-                if len(available) > 5:
-                    line = f"    \033[93m[{option_num}]\033[0m \033[2mShow all {len(available)} models...\033[0m"
-                    self.print_box_line(line, width)
-                    option_num += 1
-                
-                self.print_empty_line(width)
-                self.print_box_separator(width)
-                self.print_empty_line(width)
-            
-            # Download new model options
-            self.print_box_line("  \033[96mDownload New Model:\033[0m", width)
-            self.print_empty_line(width)
-            
-            # Show format in dimmed color
-            line = f"    \033[2mEnter repository ID (e.g., meta-llama/Llama-3.2-3B)\033[0m"
-            self.print_box_line(line, width)
-            
-            self.print_empty_line(width)
-            self.print_box_footer(width)
-            
-            # Get user choice
-            choice = self.get_input_with_escape("Choice or repo ID")
-            
-            if choice is None:
-                return
-            
-            try:
-                choice_num = int(choice)
-                
-                # Load existing model
-                if available and choice_num <= len(available[:5]):
-                    model = available[choice_num - 1]
-                    print(f"\n\033[96m⚡\033[0m Loading {model['name']}...")
-                    success, msg = self.model_manager.load_model(model['path'])
-                    if success:
-                        print(f"\033[32m✓\033[0m Model loaded successfully!")
-                        
-                        # Show template information
-                        model_info = self.model_manager.get_current_model()
-                        if model_info:
-                            tokenizer = self.model_manager.tokenizers.get(model_info.name)
-                            profile = self.template_registry.setup_model(
-                                model_info.name, 
-                                tokenizer=tokenizer,
-                                interactive=False
-                            )
-                            if profile:
-                                template_name = profile.config.name
-                                print(f"   \033[2m• Template: {template_name}\033[0m")
-                    else:
-                        print(f"\033[31m✗\033[0m Failed to load: {msg}")
-                    return
-                
-                # Show all models
-                elif available and choice_num == len(available[:5]) + 1 and len(available) > 5:
-                    print()
-                    self.manage_models()  # Use the unified model manager
-                    return
-                else:
-                    print(f"\033[31m✗ Invalid choice\033[0m")
-                    return
-                    
-            except ValueError:
-                # Not a number, treat as repository ID
-                repo_id = choice
-                # Check if filename is provided
-                parts = repo_id.split()
-                repo_id = parts[0]
-                filename = parts[1] if len(parts) > 1 else None
-        
-        # Validate format
-        if '/' not in repo_id:
-            print(f"\n\033[31m✗ Invalid format. Expected: username/model-name\033[0m")
-            return
-        
-        # Show download starting
-        print(f"\n\033[96m⬇\033[0m Downloading: \033[93m{repo_id}\033[0m")
-        if filename:
-            print(f"   File: \033[93m{filename}\033[0m")
-        print()
-        
-        success, message, path = self.model_downloader.download_model(repo_id, filename)
-        
-        if success:
-            # Success message in a nice box
-            width = min(self.get_terminal_width() - 2, 70)
-            print()
-            # Create a custom header with green color for success
-            title_with_color = " \033[32mDownload Complete\033[0m "
-            visible_len = self.get_visible_length(title_with_color)
-            padding = width - visible_len - 3  # -3 for "╭─" and "╮"
-            print(f"╭─{title_with_color}" + "─" * padding + "╮")
-            self.print_box_line("  \033[32m✓\033[0m Model downloaded successfully!", width)
-            
-            location_str = str(path)[:width-13]
-            self.print_box_line(f"  \033[2mLocation: {location_str}\033[0m", width)
-            self.print_empty_line(width)
-            self.print_box_line("  \033[96mLoad this model now?\033[0m", width)
-            self.print_box_line("  \033[93m[Y]es\033[0m  \033[2m[N]o\033[0m", width)
-            self.print_box_footer(width)
-            
-            try:
-                choice = input("\n\033[96m▶\033[0m Choice (\033[93my\033[0m/\033[2mn\033[0m): ").strip().lower()
-                if choice in ['y', 'yes']:
-                    print(f"\n\033[96m⚡\033[0m Loading model...")
-                    load_success, load_msg = self.model_manager.load_model(str(path))
-                    if load_success:
-                        print(f"\033[32m✓\033[0m Model loaded successfully!")
-                    else:
-                        print(f"\033[31m✗\033[0m Failed to load: {load_msg}")
-            except KeyboardInterrupt:
-                print("\n\033[2mCancelled\033[0m")
-        else:
-            print(f"\n\033[31m✗\033[0m {message}")
+        model_ui.download_model(cli=self, args=args)
     
     def hf_login(self):
         """Login to HuggingFace for accessing gated models."""
-        try:
-            from huggingface_hub import login, HfApi
-            from huggingface_hub.utils import HfHubHTTPError
-        except ImportError:
-            print("\n\033[31m✗\033[0m huggingface-hub not installed. Install with: pip install huggingface-hub")
-            return
-        
-        width = min(self.get_terminal_width() - 2, 70)
-        
-        # Create login UI box
-        print()
-        self.print_box_header("HuggingFace Login", width)
-        self.print_empty_line(width)
-        
-        # Check if already logged in
-        try:
-            api = HfApi()
-            user_info = api.whoami()
-            if user_info:
-                username = user_info.get('name', 'Unknown')
-                self.print_box_line(f"  \033[32m✓\033[0m Already logged in as: \033[93m{username}\033[0m", width)
-                self.print_empty_line(width)
-                self.print_box_line("  \033[96mOptions:\033[0m", width)
-                self.print_box_line("  \033[93m[1]\033[0m Login with new token", width)
-                self.print_box_line("  \033[93m[2]\033[0m Logout", width)
-                self.print_box_line("  \033[93m[3]\033[0m Cancel", width)
-                self.print_box_footer(width)
-                
-                choice = self.get_input_with_escape("Select option (1-3)")
-                if choice == '1':
-                    # Continue to login flow
-                    pass
-                elif choice == '2':
-                    # Logout
-                    from huggingface_hub import logout
-                    logout()
-                    print("\n\033[32m✓\033[0m Successfully logged out from HuggingFace")
-                    return
-                else:
-                    return
-        except:
-            # Not logged in, continue to login flow
-            pass
-        
-        # Show login instructions
-        print()
-        self.print_box_header("HuggingFace Login", width)
-        self.print_empty_line(width)
-        self.print_box_line("  To access gated models, you need a HuggingFace token.", width)
-        self.print_empty_line(width)
-        self.print_box_line("  \033[96m1.\033[0m Get your token from:", width)
-        self.print_box_line("     \033[93mhttps://huggingface.co/settings/tokens\033[0m", width)
-        self.print_empty_line(width)
-        self.print_box_line("  \033[96m2.\033[0m Create a token with \033[93mread\033[0m permissions", width)
-        self.print_empty_line(width)
-        self.print_box_line("  \033[96m3.\033[0m Paste the token below (input hidden)", width)
-        self.print_box_footer(width)
-        
-        # Get token with hidden input
-        print()
-        token = getpass.getpass("\033[96m▶\033[0m Enter token \033[2m(or press Enter to cancel)\033[0m: ")
-        
-        if not token:
-            print("\033[2mCancelled\033[0m")
-            return
-        
-        # Try to login
-        print("\n\033[96m⚡\033[0m Authenticating with HuggingFace...")
-        try:
-            login(token=token, add_to_git_credential=True)
-            
-            # Verify login
-            api = HfApi()
-            user_info = api.whoami()
-            username = user_info.get('name', 'Unknown')
-            
-            print(f"\033[32m✓\033[0m Successfully logged in as: \033[93m{username}\033[0m")
-            print("\033[2m  Token saved for future use\033[0m")
-            print("\033[2m  You can now download gated models\033[0m")
-            
-        except HfHubHTTPError as e:
-            if "Invalid token" in str(e):
-                print("\033[31m✗\033[0m Invalid token. Please check your token and try again.")
-            else:
-                print(f"\033[31m✗\033[0m Login failed: {str(e)}")
-        except Exception as e:
-            print(f"\033[31m✗\033[0m Login failed: {str(e)}")
+        model_ui.hf_login(cli=self)
     
     def manage_models(self, args: str = ""):
         """Interactive model manager - simplified for better UX.
         If args provided, tries to load that model directly."""
-        
-        # If args provided, try direct load
-        if args:
-            print(f"\033[96m⚡\033[0m Loading model: \033[93m{args}\033[0m...")
-            success, message = self.model_manager.load_model(args)
-            if success:
-                print(f"\033[32m✓\033[0m Model loaded successfully")
-            else:
-                print(f"\033[31m✗\033[0m Failed: {message}", file=sys.stderr)
-            return
-        
-        # Interactive mode
-        available = self.model_manager.discover_available_models()
-        
-        if not available:
-            print(f"\n\033[31m✗\033[0m No models found in \033[2m{self.config.model.model_path}\033[0m")
-            print("Use \033[93m/download\033[0m to download models from HuggingFace")
-            return
-        
-        width = min(self.get_terminal_width() - 2, 70)
-        
-        # Build the model manager dialog using helper methods
-        print()
-        self.print_box_header("Select Model", width)
-        self.print_empty_line(width)
-        
-        # List models with numbers - simplified view
-        for i, model in enumerate(available, 1):
-            # Model name and size
-            name = model['name'][:width-30]
-            size = f"{model['size_gb']:.1f}GB"
-            
-            # Check if currently loaded (handle both original name and MLX cached name)
-            current_model = self.model_manager.current_model or ""
-            is_current = (model['name'] == current_model or 
-                         model.get('mlx_name') == current_model or
-                         current_model.endswith(model['name']))
-            
-            # Build status indicators
-            status_parts = []
-            if model.get('mlx_optimized'):
-                status_parts.append("\033[36m⚡ MLX\033[0m")  # Cyan lightning for MLX
-            elif model.get('mlx_available'):
-                status_parts.append("\033[2m○ MLX ready\033[0m")  # Dim circle for can be optimized
-            
-            if is_current:
-                status_parts.append("\033[32m● loaded\033[0m")
-            
-            status = " ".join(status_parts) if status_parts else ""
-            
-            # Format the line
-            if model.get('mlx_optimized'):
-                # Show optimized model with special formatting
-                line = f"  \033[93m[{i}]\033[0m {name} \033[2m({size})\033[0m {status}"
-            else:
-                line = f"  \033[93m[{i}]\033[0m {name} \033[2m({size})\033[0m {status}"
-            
-            self.print_box_line(line, width)
-        
-        self.print_empty_line(width)
-        self.print_box_separator(width)
-        self.print_empty_line(width)
-        
-        # Additional options
-        self.print_box_line(f"  \033[93m[D]\033[0m Delete a model", width)
-        self.print_box_line(f"  \033[93m[N]\033[0m Download new model", width)
-        
-        self.print_empty_line(width)
-        self.print_box_footer(width)
-        
-        # Get user choice
-        choice = self.get_input_with_escape(f"Select model to load (1-{len(available)}) or option")
-        
-        if choice is None:
-            return
-        
-        choice = choice.lower()
-        
-        if choice == 'n':
-            self.download_model()
-            return
-        elif choice == 'd':
-            # Delete mode - show models again for deletion
-            del_choice = self.get_input_with_escape(f"Select model to delete (1-{len(available)})")
-            if del_choice is None:
-                return
-            try:
-                model_idx = int(del_choice) - 1
-                if 0 <= model_idx < len(available):
-                    selected_model = available[model_idx]
-                    print(f"\n\033[31m⚠\033[0m Delete \033[93m{selected_model['name']}\033[0m?")
-                    print(f"   This will free \033[93m{selected_model['size_gb']:.1f}GB\033[0m of disk space.")
-                    confirm = self.get_input_with_escape("Confirm deletion (\033[93my\033[0m/\033[2mN\033[0m)")
-                    if confirm is None:
-                        return
-                    confirm = confirm.lower()
-                    
-                    if confirm == 'y':
-                        # Delete the model
-                        model_path = Path(selected_model['path'])
-                        try:
-                            if model_path.is_file():
-                                model_path.unlink()
-                            elif model_path.is_dir():
-                                import shutil
-                                shutil.rmtree(model_path)
-                            
-                            print(f"\033[32m✓\033[0m Model deleted successfully. Freed \033[93m{selected_model['size_gb']:.1f}GB\033[0m.")
-                            
-                            # If this was the current model, clear it
-                            if selected_model['name'] == self.model_manager.current_model:
-                                self.model_manager.current_model = None
-                                print("\033[2mNote: Deleted model was currently loaded. Load another model to continue.\033[0m")
-                        except Exception as e:
-                            print(f"\033[31m✗\033[0m Failed to delete: {str(e)}")
-                    else:
-                        print("\033[2mDeletion cancelled.\033[0m")
-            except (ValueError, IndexError):
-                print("\033[31m✗\033[0m Invalid selection")
-            return
-        
-        try:
-            model_idx = int(choice) - 1
-            if 0 <= model_idx < len(available):
-                selected_model = available[model_idx]
-                
-                # If already loaded, inform user
-                if selected_model['name'] == self.model_manager.current_model:
-                    print(f"\033[2mModel already loaded: {selected_model['name']}\033[0m")
-                    return
-                
-                # Load model directly - no second prompt
-                print(f"\n\033[96m⚡\033[0m Loading \033[93m{selected_model['name']}\033[0m...")
-                success, message = self.model_manager.load_model(selected_model['path'])
-                if success:
-                    # Show the same detailed info as startup
-                    model_info = self.model_manager.get_current_model()
-                    if model_info:
-                        # Determine quantization type from name or model info
-                        model_name = model_info.name
-                        if "_4bit" in model_name or "4bit" in str(model_info.quantization):
-                            quant_type = "4-bit"
-                        elif "_5bit" in model_name or "5bit" in str(model_info.quantization):
-                            quant_type = "5-bit"
-                        elif "_8bit" in model_name or "8bit" in str(model_info.quantization):
-                            quant_type = "8-bit"
-                        else:
-                            quant_type = ""  # Don't duplicate "quantized"
-                        
-                        # Clean model name for display
-                        clean_name = selected_model['name']
-                        if clean_name.startswith("_Users_"):
-                            # Extract just the model name from the path
-                            parts = clean_name.split("_")
-                            for i, part in enumerate(parts):
-                                if "models" in part:
-                                    clean_name = "_".join(parts[i+1:])
-                                    break
-                        clean_name = clean_name.replace("_4bit", "").replace("_5bit", "").replace("_8bit", "")
-                        
-                        # Format the model format nicely
-                        format_display = model_info.format.value
-                        if format_display.lower() == "mlx":
-                            format_display = "MLX (Apple Silicon optimized)"
-                        elif format_display.lower() == "gguf":
-                            format_display = "GGUF"  # Remove redundant "(quantized)"
-                        elif format_display.lower() == "safetensors":
-                            format_display = "SafeTensors"
-                        elif format_display.lower() == "pytorch":
-                            format_display = "PyTorch"
-                        
-                        print(f" \033[32m✓\033[0m Model ready: \033[93m{clean_name}\033[0m")
-                        # Show quantization info only if we have specific type
-                        if quant_type:
-                            print(f"   \033[2m• Size: {model_info.size_gb:.1f}GB ({quant_type} quantized)\033[0m")
-                        else:
-                            print(f"   \033[2m• Size: {model_info.size_gb:.1f}GB (quantized)\033[0m")
-                        print(f"   \033[2m• Optimizations: AMX acceleration, operation fusion\033[0m")
-                        print(f"   \033[2m• Format: {format_display}\033[0m")
-                        
-                        # Show template information
-                        tokenizer = self.model_manager.tokenizers.get(model_info.name)
-                        profile = self.template_registry.setup_model(
-                            model_info.name,
-                            tokenizer=tokenizer,
-                            interactive=False
-                        )
-                        if profile:
-                            template_name = profile.config.name
-                            print(f"   \033[2m• Template: {template_name}\033[0m")
-                    else:
-                        print(f"\033[32m✓\033[0m Model loaded successfully!")
-                else:
-                    print(f"\033[31m✗\033[0m Failed to load: {message}")
-            else:
-                print("\033[31m✗\033[0m Invalid selection")
-        except ValueError:
-            print("\033[31m✗\033[0m Invalid choice")
+        model_ui.manage_models(cli=self, args=args)
     
     def clear_conversation(self):
         """Clear conversation history."""
@@ -1039,76 +423,15 @@ class CortexCLI:
     
     def show_status(self):
         """Show current setup status."""
-        is_valid, gpu_info, errors = self.gpu_validator.validate()
-        
-        width = min(self.get_terminal_width() - 2, 70)  # Consistent width with other dialogs
-        
-        print()
-        self.print_box_header("Current Setup", width)
-        self.print_empty_line(width)
-        
-        # GPU Info
-        if gpu_info:
-            self.print_box_line(f"  \033[2mGPU:\033[0m \033[93m{gpu_info.chip_name}\033[0m", width)
-            self.print_box_line(f"  \033[2mCores:\033[0m \033[93m{gpu_info.gpu_cores}\033[0m", width)
-            
-            mem_gb = gpu_info.total_memory / (1024**3)
-            mem_str = f"{mem_gb:.1f} GB"
-            self.print_box_line(f"  \033[2mMemory:\033[0m \033[93m{mem_str}\033[0m", width)
-        
-        # Model Info
-        if self.model_manager.current_model:
-            model_info = self.model_manager.get_current_model()
-            if model_info:
-                self.print_box_line(f"  \033[2mModel:\033[0m \033[93m{model_info.name[:43]}\033[0m", width)
-                
-                # Template info
-                tokenizer = self.model_manager.tokenizers.get(model_info.name)
-                profile = self.template_registry.get_template(model_info.name)
-                if profile:
-                    template_name = profile.config.name
-                    self.print_box_line(f"  \033[2mTemplate:\033[0m \033[93m{template_name}\033[0m", width)
-        else:
-            self.print_box_line(f"  \033[2mModel:\033[0m \033[31mNone loaded\033[0m", width)
-        
-        self.print_empty_line(width)
-        self.print_box_footer(width)
+        status_ui.show_status(cli=self)
     
     def show_gpu_status(self):
         """Show GPU status."""
-        is_valid, gpu_info, errors = self.gpu_validator.validate()
-        if gpu_info:
-            print(f"\n\033[96mGPU Information:\033[0m")
-            print(f"  Chip: \033[93m{gpu_info.chip_name}\033[0m")
-            print(f"  GPU Cores: \033[93m{gpu_info.gpu_cores}\033[0m")
-            print(f"  Total Memory: \033[93m{gpu_info.total_memory / (1024**3):.1f} GB\033[0m")
-            print(f"  Available Memory: \033[93m{gpu_info.available_memory / (1024**3):.1f} GB\033[0m")
-            print(f"  Metal Support: {'\033[32mYes\033[0m' if gpu_info.has_metal else '\033[31mNo\033[0m'}")
-            print(f"  MPS Support: {'\033[32mYes\033[0m' if gpu_info.has_mps else '\033[31mNo\033[0m'}")
-        
-        memory_status = self.model_manager.get_memory_status()
-        print(f"\n\033[96mMemory Status:\033[0m")
-        print(f"  Available: \033[93m{memory_status['available_gb']:.1f} GB\033[0m")
-        print(f"  Models Loaded: \033[93m{memory_status['models_loaded']}\033[0m")
-        print(f"  Model Memory: \033[93m{memory_status['model_memory_gb']:.1f} GB\033[0m")
+        status_ui.show_gpu_status(cli=self)
     
     def run_benchmark(self):
         """Run performance benchmark."""
-        if not self.model_manager.current_model:
-            print("\033[31m✗\033[0m No model loaded.")
-            return
-        
-        print("\033[96m⚡\033[0m Running benchmark (100 tokens)...")
-        metrics = self.inference_engine.benchmark()
-        
-        if metrics:
-            print(f"\n\033[96mBenchmark Results:\033[0m")
-            print(f"  Tokens Generated: \033[93m{metrics.tokens_generated}\033[0m")
-            print(f"  Time: \033[93m{metrics.time_elapsed:.2f}s\033[0m")
-            print(f"  Tokens/Second: \033[93m{metrics.tokens_per_second:.1f}\033[0m")
-            print(f"  First Token: \033[93m{metrics.first_token_latency:.3f}s\033[0m")
-            print(f"  GPU Usage: \033[93m{metrics.gpu_utilization:.1f}%\033[0m")
-            print(f"  Memory: \033[93m{metrics.memory_used_gb:.1f}GB\033[0m")
+        status_ui.run_benchmark(cli=self)
     
     def manage_template(self, args: str = ""):
         """Manage template configuration for the current model."""
@@ -1329,7 +652,7 @@ class CortexCLI:
 
                 if tool_calls:
                     tool_results = self.tool_runner.run_calls(tool_calls)
-                    self._print_tool_activity(tool_calls, tool_results)
+                    print_tool_activity(self.console, tool_calls, tool_results, self.get_terminal_width())
                     self.conversation_manager.add_message(
                         MessageRole.SYSTEM,
                         tool_protocol.format_tool_results(tool_results)
@@ -1382,351 +705,22 @@ class CortexCLI:
     
     def _format_prompt_with_chat_template(self, user_input: str, include_user: bool = True) -> str:
         """Format the prompt with appropriate chat template for the model."""
-        # Get current conversation context
-        conversation = self.conversation_manager.get_current_conversation()
-        
-        # Get the tokenizer for the current model
-        model_name = self.model_manager.current_model
-        tokenizer = self.model_manager.tokenizers.get(model_name)
-        
-        # Build messages list from conversation history
-        messages = []
-        
-        # Add conversation history if exists
-        if conversation and conversation.messages:
-            # Include recent context (last few messages)
-            context_messages = conversation.messages[-10:]  # Last 10 messages for context
-            for msg in context_messages:
-                messages.append({
-                    "role": msg.role.value,
-                    "content": msg.content
-                })
-        
-        # Add current user message
-        if include_user:
-            messages.append({
-                "role": "user",
-                "content": user_input
-            })
-        
-        # Use template registry to format messages
-        try:
-            # Setup model template if not already configured
-            profile = self.template_registry.setup_model(
-                model_name, 
-                tokenizer=tokenizer,
-                interactive=False  # Non-interactive for smoother experience
-            )
-            
-            # Format messages using the template
-            formatted = profile.format_messages(messages, add_generation_prompt=True)
-            
-            # DEBUG: Uncomment to see formatted prompt
-            # print(f"\033[36m[DEBUG] Using template: {profile.config.name}\033[0m", file=sys.stderr)
-            # print(f"\033[36m[DEBUG] Formatted prompt preview: {formatted[:200]}...\033[0m", file=sys.stderr)
-            
-            return formatted
-            
-        except (AttributeError, TypeError, ValueError) as e:
-            # Fallback to old method if template registry fails
-            logger.debug(f"Template registry failed: {e}, using fallback")
-            
-            if tokenizer and hasattr(tokenizer, 'apply_chat_template'):
-                # Try direct tokenizer method
-                try:
-                    formatted = tokenizer.apply_chat_template(
-                        messages,
-                        tokenize=False,
-                        add_generation_prompt=True
-                    )
-                    return formatted
-                except (AttributeError, TypeError, ValueError) as e:
-                    logger.debug(f"Tokenizer apply_chat_template failed: {e}")
-        
-        # Fallback: For TinyLlama and other chat models, use the proper format
-        # Check if it's a chat model
-        if model_name and "chat" in model_name.lower():
-            # DEBUG: Uncomment to see when fallback chat format is used
-            # This occurs when tokenizer doesn't have apply_chat_template method
-            # print(f"\033[35m[DEBUG] Using chat model fallback for: {model_name}\033[0m", file=sys.stderr)
-            
-            # Use the proper chat format for TinyLlama and similar models
-            # Build conversation history
-            history = ""
-            if conversation and conversation.messages:
-                recent_messages = conversation.messages[-6:]  # Get last few messages
-                for msg in recent_messages:
-                    if msg.role == MessageRole.USER:
-                        history += f"<|user|>\n{msg.content}</s>\n"
-                    elif msg.role == MessageRole.ASSISTANT:
-                        history += f"<|assistant|>\n{msg.content}</s>\n"
-            
-            # Add current user message with proper format
-            prompt = f"{history}<|user|>\n{user_input}</s>\n<|assistant|>\n"
-            
-            # DEBUG: Uncomment to confirm fallback format was applied
-            # print(f"\033[35m[DEBUG] Chat fallback format used\033[0m", file=sys.stderr)
-            return prompt
-        
-        # Generic fallback for non-chat models
-        if conversation and len(conversation.messages) > 0:
-            # Include some conversation history
-            context = ""
-            recent_messages = conversation.messages[-6:]  # Get last few messages
-            for msg in recent_messages:
-                if msg.role == MessageRole.USER:
-                    context += f"User: {msg.content}\n"
-                elif msg.role == MessageRole.ASSISTANT:
-                    context += f"Assistant: {msg.content}\n"
-            
-            # Add current exchange
-            prompt = f"{context}User: {user_input}\nAssistant:"
-        else:
-            # First message in conversation - use simple format
-            prompt = f"User: {user_input}\nAssistant:"
-        
-        return prompt
+        return format_prompt_with_chat_template(
+            conversation_manager=self.conversation_manager,
+            model_manager=self.model_manager,
+            template_registry=self.template_registry,
+            user_input=user_input,
+            include_user=include_user,
+            logger=logger,
+        )
     
     def get_input_from_box(self) -> str:
-        """Get user input from a styled input box.
-        
-        Displays a green-bordered input box, collects user input, then converts
-        the box to a simple prompt in the conversation history.
-        
-        Guarantees that the input box is fully cleared after submission so
-        no borders/pipes remain on screen.
-        """
-        width = self.get_terminal_width()
-        
-        # ANSI codes
-        GREEN = "\033[92m"
-        YELLOW = "\033[93m"
-        DIM = "\033[2m"
-        RESET = "\033[0m"
-        CLEAR_LINE = "\033[2K"
-        CLEAR_TO_EOL = "\033[K"
-        CURSOR_UP = "\033[A"
-        CURSOR_DOWN = "\033[B"
-        MOVE_COL = lambda n: f"\033[{n}G"
-        
-        # Get current model name for display
-        current_model = ""
-        if self.model_manager.current_model:
-            model_name = os.path.basename(self.model_manager.current_model)
-            # Display full model name without truncation
-            current_model = f"{DIM}Model:{RESET} {YELLOW}{model_name}{RESET}"
-        
-        # Draw the input box with dim borders
-        print()
-        print(f"{DIM}╭{'─' * (width - 2)}╮{RESET}")
-        print(f"{DIM}│{RESET}{' ' * (width - 2)}{DIM}│{RESET}")
-        print(f"{DIM}│{RESET}{' ' * (width - 2)}{DIM}│{RESET}")
-        print(f"{DIM}│{RESET}{' ' * (width - 2)}{DIM}│{RESET}")
-        print(f"{DIM}╰{'─' * (width - 2)}╯{RESET}")
-        
-        # Bottom hint: show current model aligned with box
-        if current_model:
-            print(f"{current_model}")
-        else:
-            print()  # Empty line if no model loaded
-        
-        # Move cursor to input position inside the box (center of 3 interior lines)
-        sys.stdout.write("\033[4A")  # Move up 4 lines to the input line
-        sys.stdout.write(f"\r{DIM}│{RESET} > ")  # Position at prompt
-        sys.stdout.flush()
-        
-        try:
-            # Get user input with custom character handling
-            user_input = self._get_protected_input(width)
-            
-            # After _get_protected_input returns, the cursor is at the start of the
-            # bottom border line (due to CRLFs when Enter was pressed).
-            # Explicitly clear the entire input box region using relative moves.
-            # 1) Clear hint line (one line below bottom border)
-            sys.stdout.write(f"{CURSOR_DOWN}\r{CLEAR_LINE}")
-            # 2) Clear bottom border
-            sys.stdout.write(f"{CURSOR_UP}\r{CLEAR_LINE}")
-            # 3) Clear padding line
-            sys.stdout.write(f"{CURSOR_UP}\r{CLEAR_LINE}")
-            # 4) Clear input line
-            sys.stdout.write(f"{CURSOR_UP}\r{CLEAR_LINE}")
-            # 5) Clear padding line
-            sys.stdout.write(f"{CURSOR_UP}\r{CLEAR_LINE}")
-            # 6) Clear top border
-            sys.stdout.write(f"{CURSOR_UP}\r{CLEAR_LINE}")
-            
-            # Position cursor at the start of where the top border was and print
-            # the clean prompt that represents the submitted user message.
-            sys.stdout.write("\r> " + user_input.strip() + "\n")
-            sys.stdout.flush()
-            
-            return user_input.strip()
-            
-        except KeyboardInterrupt:
-            # Cleanup already done in _get_protected_input before raising
-            raise
-        except EOFError:
-            # Clean up the box on Ctrl+D by clearing the lines if possible.
-            # We are on the input line.
-            try:
-                sys.stdout.write(f"\r{CLEAR_LINE}")  # input line
-                sys.stdout.write(f"{CURSOR_DOWN}\r{CLEAR_LINE}")  # padding line
-                sys.stdout.write(f"{CURSOR_DOWN}\r{CLEAR_LINE}")  # bottom border
-                sys.stdout.write(f"{CURSOR_DOWN}\r{CLEAR_LINE}")  # hint line
-                sys.stdout.write(f"{CURSOR_UP}\r{CLEAR_LINE}")  # bottom border
-                sys.stdout.write(f"{CURSOR_UP}\r{CLEAR_LINE}")  # padding line
-                sys.stdout.write(f"{CURSOR_UP}\r{CLEAR_LINE}")  # input line
-                sys.stdout.write(f"{CURSOR_UP}\r{CLEAR_LINE}")  # padding line
-                sys.stdout.write(f"{CURSOR_UP}\r{CLEAR_LINE}")  # top border
-                sys.stdout.flush()
-            finally:
-                pass
-            raise
-    
-    def _get_protected_input(self, box_width: int) -> str:
-        """Get input with protection against deleting the prompt.
-        
-        This method reads input character by character and prevents
-        the user from backspacing past the beginning of their input.
-        """
-        DIM = "\033[2m"
-        RESET = "\033[0m"
-        CLEAR_TO_END = "\033[K"
-        SAVE_CURSOR = "\033[s"
-        RESTORE_CURSOR = "\033[u"
-        
-        # Calculate usable width for text (box_width - borders - prompt)
-        # box_width - 2 (borders) - 4 (prompt " > ")
-        max_display_width = box_width - 6
-        
-        # Store terminal settings
-        old_settings = termios.tcgetattr(sys.stdin)
-        
-        try:
-            # Set terminal to raw mode for character-by-character input
-            # Disable ISIG so we can handle Ctrl+C manually for clean exit
-            new_settings = termios.tcgetattr(sys.stdin)
-            new_settings[3] = new_settings[3] & ~termios.ICANON  # Disable canonical mode
-            new_settings[3] = new_settings[3] & ~termios.ECHO    # Disable echo
-            new_settings[3] = new_settings[3] & ~termios.ISIG     # Disable signals - we'll handle Ctrl+C manually
-            new_settings[6][termios.VMIN] = 1   # Read at least 1 character
-            new_settings[6][termios.VTIME] = 0  # No timeout
-            termios.tcsetattr(sys.stdin, termios.TCSADRAIN, new_settings)
-            
-            input_buffer = []
-            cursor_pos = 0
-            view_offset = 0  # For horizontal scrolling when text exceeds width
-            
-            def redraw_line():
-                """Redraw the entire input line with proper boundaries."""
-                nonlocal view_offset
-                
-                # Calculate what portion of text to display
-                if len(input_buffer) <= max_display_width:
-                    # Text fits within box
-                    display_text = ''.join(input_buffer)
-                    display_cursor_pos = cursor_pos
-                else:
-                    # Text needs scrolling
-                    # Ensure cursor is visible in the viewport
-                    if cursor_pos < view_offset:
-                        # Cursor moved left out of view
-                        view_offset = cursor_pos
-                    elif cursor_pos >= view_offset + max_display_width:
-                        # Cursor moved right out of view
-                        view_offset = cursor_pos - max_display_width + 1
-                    
-                    # Extract visible portion
-                    display_text = ''.join(input_buffer[view_offset:view_offset + max_display_width])
-                    display_cursor_pos = cursor_pos - view_offset
-                
-                # Clear line and redraw
-                sys.stdout.write(f"\r{DIM}│{RESET} > {display_text}{CLEAR_TO_END}")
-                
-                # Draw right border at the correct position
-                # box_width is the full width including borders, so border is at box_width position
-                sys.stdout.write(f"\033[{box_width}G")  # Move to border column
-                sys.stdout.write(f"{DIM}│{RESET}")
-                
-                # Position cursor at the correct location
-                cursor_column = 5 + display_cursor_pos  # 5 = "│ > " 
-                sys.stdout.write(f"\033[{cursor_column}G")
-                sys.stdout.flush()
-            
-            # Initial display
-            redraw_line()
-            
-            while True:
-                char = sys.stdin.read(1)
-                
-                # Handle special characters
-                if char == '\r' or char == '\n':  # Enter key
-                    sys.stdout.write('\r\n')
-                    sys.stdout.write('\r\n')
-                    sys.stdout.flush()
-                    break
-                    
-                elif char == '\x7f' or char == '\x08':  # Backspace (DEL or BS)
-                    # Only allow backspace if there are characters to delete
-                    if cursor_pos > 0:
-                        cursor_pos -= 1
-                        input_buffer.pop(cursor_pos)
-                        redraw_line()
-                    # If cursor_pos is 0, do nothing (can't delete the prompt)
-                    
-                elif char == '\x03':  # Ctrl+C
-                    # Clean up the display before raising KeyboardInterrupt
-                    # We're in the input line, need to clear the entire box
-                    sys.stdout.write("\r\033[2K")  # Clear current line
-                    sys.stdout.write("\033[1B\r\033[2K")  # Down 1, clear padding line
-                    sys.stdout.write("\033[1B\r\033[2K")  # Down 1, clear bottom border
-                    sys.stdout.write("\033[1B\r\033[2K")  # Down 1, clear model line  
-                    sys.stdout.write("\033[4A\r\033[2K")  # Up 4 to padding line, clear
-                    sys.stdout.write("\033[1A\r\033[2K")  # Up 1 to top border, clear
-                    sys.stdout.write("\033[1A\r\033[2K")  # Up 1 to empty line, clear
-                    sys.stdout.write("\r")  # Position at start
-                    sys.stdout.flush()
-                    # Now raise the interrupt for clean exit
-                    raise KeyboardInterrupt
-                    
-                elif char == '\x04':  # Ctrl+D
-                    raise EOFError
-                    
-                elif char == '\x1b':  # ESC sequence (arrow keys, etc.)
-                    # Read the rest of the escape sequence
-                    next1 = sys.stdin.read(1)
-                    if next1 == '[':
-                        next2 = sys.stdin.read(1)
-                        if next2 == 'D':  # Left arrow
-                            if cursor_pos > 0:
-                                cursor_pos -= 1
-                                redraw_line()
-                        elif next2 == 'C':  # Right arrow
-                            if cursor_pos < len(input_buffer):
-                                cursor_pos += 1
-                                redraw_line()
-                        elif next2 == 'H':  # Home
-                            cursor_pos = 0
-                            view_offset = 0
-                            redraw_line()
-                        elif next2 == 'F':  # End
-                            cursor_pos = len(input_buffer)
-                            redraw_line()
-                        # For other sequences, continue without action
-                        continue
-                    
-                elif ord(char) >= 32:  # Printable character
-                    # Insert character at cursor position
-                    input_buffer.insert(cursor_pos, char)
-                    cursor_pos += 1
-                    redraw_line()
-            
-            return ''.join(input_buffer)
-            
-        finally:
-            # Restore terminal settings
-            termios.tcsetattr(sys.stdin, termios.TCSADRAIN, old_settings)
-    
+        """Get user input from a styled input box."""
+        return prompt_input_box(
+            console=self.console,
+            terminal_width=self.get_terminal_width(),
+            current_model_path=self.model_manager.current_model,
+        )
     
     def run(self):
         """Main REPL loop."""