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

cortex/ui/cli_commands.py

@@ -0,0 +1,61 @@
+"""Slash command parsing and dispatch for the CLI."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable
+
+
+@dataclass(frozen=True)
+class CommandHandlers:
+    show_help: Callable[[], None]
+    manage_models: Callable[[str], None]
+    download_model: Callable[[str], None]
+    clear_conversation: Callable[[], None]
+    save_conversation: Callable[[], None]
+    show_status: Callable[[], None]
+    show_gpu_status: Callable[[], None]
+    run_benchmark: Callable[[], None]
+    manage_template: Callable[[str], None]
+    run_finetune: Callable[[], None]
+    hf_login: Callable[[], None]
+    show_shortcuts: Callable[[], None]
+
+
+def handle_command(command: str, handlers: CommandHandlers) -> 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":
+        handlers.show_help()
+    elif cmd == "/model":
+        handlers.manage_models(args)
+    elif cmd == "/download":
+        handlers.download_model(args)
+    elif cmd == "/clear":
+        handlers.clear_conversation()
+    elif cmd == "/save":
+        handlers.save_conversation()
+    elif cmd == "/status":
+        handlers.show_status()
+    elif cmd == "/gpu":
+        handlers.show_gpu_status()
+    elif cmd == "/benchmark":
+        handlers.run_benchmark()
+    elif cmd == "/template":
+        handlers.manage_template(args)
+    elif cmd == "/finetune":
+        handlers.run_finetune()
+    elif cmd == "/login":
+        handlers.hf_login()
+    elif cmd in ["/quit", "/exit"]:
+        return False
+    elif cmd == "?":
+        handlers.show_shortcuts()
+    else:
+        print(f"\033[31mUnknown command: {cmd}\033[0m")
+        print("\033[2mType /help for available commands\033[0m")
+
+    return True

cortex/ui/cli_prompt.py

@@ -0,0 +1,96 @@
+"""Prompt formatting helpers for chat templates."""
+
+from __future__ import annotations
+
+from cortex.conversation_manager import MessageRole
+
+
+def format_prompt_with_chat_template(
+    *,
+    conversation_manager,
+    model_manager,
+    template_registry,
+    user_input: str,
+    include_user: bool = True,
+    logger=None,
+) -> str:
+    """Format the prompt with the appropriate chat template for the model."""
+    # Get current conversation context
+    conversation = conversation_manager.get_current_conversation()
+
+    # Get the tokenizer for the current model
+    model_name = model_manager.current_model
+    tokenizer = model_manager.tokenizers.get(model_name)
+
+    # Build messages list from conversation history
+    messages = []
+    if conversation and conversation.messages:
+        context_messages = conversation.messages[-10:]
+        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:
+        profile = template_registry.setup_model(
+            model_name,
+            tokenizer=tokenizer,
+            interactive=False
+        )
+        formatted = profile.format_messages(messages, add_generation_prompt=True)
+        return formatted
+
+    except (AttributeError, TypeError, ValueError) as e:
+        if logger is not None:
+            logger.debug(f"Template registry failed: {e}, using fallback")
+
+        if tokenizer and hasattr(tokenizer, 'apply_chat_template'):
+            try:
+                formatted = tokenizer.apply_chat_template(
+                    messages,
+                    tokenize=False,
+                    add_generation_prompt=True
+                )
+                return formatted
+            except (AttributeError, TypeError, ValueError) as e:
+                if logger is not None:
+                    logger.debug(f"Tokenizer apply_chat_template failed: {e}")
+
+    # Fallback: For TinyLlama and other chat models, use the proper format
+    if model_name and "chat" in model_name.lower():
+        history = ""
+        if conversation and conversation.messages:
+            recent_messages = conversation.messages[-6:]
+            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"
+
+        prompt = f"{history}<|user|>\n{user_input}</s>\n<|assistant|>\n"
+        return prompt
+
+    # Generic fallback for non-chat models
+    if conversation and len(conversation.messages) > 0:
+        context = ""
+        recent_messages = conversation.messages[-6:]
+        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"
+
+        prompt = f"{context}User: {user_input}\nAssistant:"
+    else:
+        prompt = f"User: {user_input}\nAssistant:"
+
+    return prompt

cortex/ui/help_ui.py

@@ -0,0 +1,66 @@
+"""Help and shortcuts rendering for CLI."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def show_shortcuts(*, terminal_width: int, box: Any) -> None:
+    """Show keyboard shortcuts."""
+    width = min(terminal_width - 2, 70)
+
+    print()
+    box.print_box_header("Keyboard Shortcuts", width)
+    box.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:
+        colored_key = f"\033[93m{key}\033[0m"
+        key_width = len(key)
+        padding = " " * (12 - key_width)
+        line = f"  {colored_key}{padding}{desc}"
+        box.print_box_line(line, width)
+
+    box.print_empty_line(width)
+    box.print_box_footer(width)
+
+
+def show_help(*, terminal_width: int, box: Any) -> None:
+    """Show available commands."""
+    width = min(terminal_width - 2, 70)
+
+    print()
+    box.print_box_header("Available Commands", width)
+    box.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:
+        colored_cmd = f"\033[93m{cmd}\033[0m"
+        cmd_width = len(cmd)
+        padding = " " * (12 - cmd_width)
+        line = f"  {colored_cmd}{padding}{desc}"
+        box.print_box_line(line, width)
+
+    box.print_empty_line(width)
+    box.print_box_footer(width)

cortex/ui/input_box.py

@@ -0,0 +1,205 @@
+"""Input box rendering and protected input handling for CLI."""
+
+from __future__ import annotations
+
+import os
+import sys
+import termios
+from typing import Optional
+
+from rich.console import Console
+
+INPUT_BG = "\033[48;5;236m"  # Dark gray background (256-color)
+INPUT_FG = "\033[30m"        # Black text
+RESET = "\033[0m"
+PROMPT_PREFIX = "  > "
+BOX_HEIGHT = 3
+INPUT_LINE_OFFSET = BOX_HEIGHT // 2
+
+
+def prompt_input_box(
+    *,
+    console: Console,
+    terminal_width: int,
+    current_model_path: Optional[str],
+) -> str:
+    """Render the solid input box, read user input, and clean up the UI."""
+    width = terminal_width
+
+    # ANSI codes
+    yellow = "\033[93m"
+    dim = "\033[2m"
+    clear_line = "\033[2K"
+    cursor_up = "\033[A"
+    cursor_down = "\033[B"
+
+    # Model name line
+    current_model = ""
+    if current_model_path:
+        model_name = os.path.basename(current_model_path)
+        current_model = f"{dim}Model:{RESET} {yellow}{model_name}{RESET}"
+
+    # Draw the input box with a solid background (no borders)
+    print()
+    fill_line = f"{INPUT_BG}{' ' * width}{RESET}"
+    for _ in range(BOX_HEIGHT):
+        print(fill_line)
+
+    # Bottom hint: show current model aligned with box
+    if current_model:
+        print(f"{current_model}")
+    else:
+        print()
+
+    # Move cursor to input position inside the box (center line)
+    move_up = BOX_HEIGHT - INPUT_LINE_OFFSET + 1
+    sys.stdout.write(f"\033[{move_up}A")
+    sys.stdout.write(f"\r{INPUT_BG}{INPUT_FG}{PROMPT_PREFIX}")
+    sys.stdout.flush()
+
+    try:
+        user_input = _get_protected_input(width)
+
+        # Clear the input box region using relative moves.
+        sys.stdout.write(f"{cursor_down}\r{clear_line}")
+        for _ in range(INPUT_LINE_OFFSET + 3):
+            sys.stdout.write(f"{cursor_up}\r{clear_line}")
+
+        # 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:
+        raise
+    except EOFError:
+        try:
+            sys.stdout.write(f"\r{clear_line}")
+            for _ in range(BOX_HEIGHT - INPUT_LINE_OFFSET):
+                sys.stdout.write(f"{cursor_down}\r{clear_line}")
+            for _ in range(BOX_HEIGHT):
+                sys.stdout.write(f"{cursor_up}\r{clear_line}")
+            sys.stdout.flush()
+        finally:
+            pass
+        raise
+
+
+def _get_protected_input(box_width: int) -> str:
+    """Read input in raw mode and prevent deleting the prompt."""
+    # Calculate usable width for text (leave one trailing space to avoid wrap)
+    max_display_width = box_width - len(PROMPT_PREFIX) - 1
+    clear_line = "\033[2K"
+    cursor_down = "\033[1B"
+    cursor_up = "\033[1A"
+
+    # 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
+        new_settings[3] = new_settings[3] & ~termios.ECHO
+        new_settings[3] = new_settings[3] & ~termios.ISIG
+        new_settings[6][termios.VMIN] = 1
+        new_settings[6][termios.VTIME] = 0
+        termios.tcsetattr(sys.stdin, termios.TCSADRAIN, new_settings)
+
+        input_buffer = []
+        cursor_pos = 0
+        view_offset = 0
+
+        def redraw_line():
+            nonlocal view_offset
+
+            if len(input_buffer) <= max_display_width:
+                display_text = "".join(input_buffer)
+                display_cursor_pos = cursor_pos
+            else:
+                if cursor_pos < view_offset:
+                    view_offset = cursor_pos
+                elif cursor_pos >= view_offset + max_display_width:
+                    view_offset = cursor_pos - max_display_width + 1
+
+                display_text = "".join(input_buffer[view_offset:view_offset + max_display_width])
+                display_cursor_pos = cursor_pos - view_offset
+
+            pad_len = box_width - len(PROMPT_PREFIX) - len(display_text)
+            if pad_len < 0:
+                pad_len = 0
+
+            sys.stdout.write(
+                f"\r{INPUT_BG}{INPUT_FG}{PROMPT_PREFIX}{display_text}"
+                f"{' ' * pad_len}{RESET}"
+            )
+
+            cursor_column = len(PROMPT_PREFIX) + 1 + display_cursor_pos
+            sys.stdout.write(f"\033[{cursor_column}G")
+            sys.stdout.flush()
+
+        redraw_line()
+
+        def clear_box_from_input():
+            sys.stdout.write(f"\r{clear_line}")
+            for _ in range(BOX_HEIGHT - INPUT_LINE_OFFSET):
+                sys.stdout.write(f"{cursor_down}\r{clear_line}")
+            for _ in range(BOX_HEIGHT):
+                sys.stdout.write(f"{cursor_up}\r{clear_line}")
+            sys.stdout.write("\r")
+            sys.stdout.flush()
+
+        while True:
+            char = sys.stdin.read(1)
+
+            if char == "\r" or char == "\n":
+                sys.stdout.write("\r\n")
+                sys.stdout.write("\r\n")
+                sys.stdout.flush()
+                break
+
+            if char == "\x7f" or char == "\x08":
+                if cursor_pos > 0:
+                    cursor_pos -= 1
+                    input_buffer.pop(cursor_pos)
+                    redraw_line()
+                continue
+
+            if char == "\x03":
+                clear_box_from_input()
+                raise KeyboardInterrupt
+
+            if char == "\x04":
+                raise EOFError
+
+            if char == "\x1b":
+                next1 = sys.stdin.read(1)
+                if next1 == "[":
+                    next2 = sys.stdin.read(1)
+                    if next2 == "D":
+                        if cursor_pos > 0:
+                            cursor_pos -= 1
+                            redraw_line()
+                    elif next2 == "C":
+                        if cursor_pos < len(input_buffer):
+                            cursor_pos += 1
+                            redraw_line()
+                    elif next2 == "H":
+                        cursor_pos = 0
+                        view_offset = 0
+                        redraw_line()
+                    elif next2 == "F":
+                        cursor_pos = len(input_buffer)
+                        redraw_line()
+                continue
+
+            if ord(char) >= 32:
+                input_buffer.insert(cursor_pos, char)
+                cursor_pos += 1
+                redraw_line()
+
+        return "".join(input_buffer)
+    finally:
+        termios.tcsetattr(sys.stdin, termios.TCSADRAIN, old_settings)