tunacode-cli 0.0.1__py3-none-any.whl

tunacode/ui/console.py

@@ -0,0 +1,74 @@
+"""Main console coordination module for Sidekick UI.
+
+This module re-exports functions from specialized UI modules to maintain
+backward compatibility while organizing code into focused modules.
+"""
+
+from rich.console import Console as RichConsole
+from rich.markdown import Markdown
+
+# Import and re-export all functions from specialized modules
+from .input import formatted_text, input, multiline_input
+from .keybindings import create_key_bindings
+from .output import (banner, clear, info, line, muted, print, spinner, success, sync_print,
+                     update_available, usage, version, warning)
+from .panels import (agent, dump_messages, error, help, models, panel, sync_panel,
+                     sync_tool_confirm, tool_confirm)
+from .prompt_manager import PromptConfig, PromptManager
+from .validators import ModelValidator
+
+# Create console object for backward compatibility
+console = RichConsole()
+
+# Create key bindings object for backward compatibility
+kb = create_key_bindings()
+
+
+# Re-export markdown utility for backward compatibility
+def markdown(text: str) -> Markdown:
+    """Create a Markdown object."""
+    return Markdown(text)
+
+
+# All functions are now available through imports above
+__all__ = [
+    # From input module
+    "formatted_text",
+    "input",
+    "multiline_input",
+    # From keybindings module
+    "create_key_bindings",
+    "kb",
+    # From output module
+    "banner",
+    "clear",
+    "console",
+    "info",
+    "line",
+    "muted",
+    "print",
+    "spinner",
+    "success",
+    "sync_print",
+    "update_available",
+    "usage",
+    "version",
+    "warning",
+    # From panels module
+    "agent",
+    "dump_messages",
+    "error",
+    "help",
+    "models",
+    "panel",
+    "sync_panel",
+    "sync_tool_confirm",
+    "tool_confirm",
+    # From prompt_manager module
+    "PromptConfig",
+    "PromptManager",
+    # From validators module
+    "ModelValidator",
+    # Local utilities
+    "markdown",
+]

tunacode/ui/constants.py

@@ -0,0 +1,16 @@
+"""UI-specific constants for Sidekick."""
+
+# UI Layout Constants
+DEFAULT_PANEL_PADDING = {"top": 1, "right": 0, "bottom": 1, "left": 0}
+
+# Spinner Configuration
+SPINNER_TYPE = "dots12"  # Modern spinner style
+SPINNER_STYLE = "#00d7ff"  # Modern cyan color
+
+# Input Configuration
+DEFAULT_PROMPT = "❯ "
+MULTILINE_PROMPT = "  ❯ "
+MAX_HISTORY_SIZE = 1000
+
+# Display Limits
+MAX_DISPLAY_LENGTH = 50  # For truncating in UI

tunacode/ui/decorators.py

@@ -0,0 +1,59 @@
+"""
+Module: sidekick.ui.decorators
+
+Provides decorators for UI functions including sync/async wrapper patterns.
+"""
+
+import asyncio
+from functools import wraps
+from typing import Any, Callable, TypeVar
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+def create_sync_wrapper(async_func: F) -> F:
+    """Create a synchronous wrapper for an async function.
+
+    This decorator does NOT modify the original async function.
+    Instead, it attaches a sync version as a 'sync' attribute.
+
+    Args:
+        async_func: The async function to wrap
+
+    Returns:
+        The original async function with sync version attached
+    """
+
+    @wraps(async_func)
+    def sync_wrapper(*args, **kwargs):
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                # If we're already in an async context, we can't use run_until_complete
+                # This might happen when called from within an async function
+                raise RuntimeError(
+                    f"Cannot call sync_{async_func.__name__} from within an async context. "
+                    f"Use await {async_func.__name__}() instead."
+                )
+        except RuntimeError:
+            # No event loop exists, create one
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+        return loop.run_until_complete(async_func(*args, **kwargs))
+
+    # Set a naming convention
+    sync_wrapper.__name__ = f"sync_{async_func.__name__}"
+    sync_wrapper.__qualname__ = f"sync_{async_func.__qualname__}"
+
+    # Update docstring to indicate this is a sync version
+    if async_func.__doc__:
+        sync_wrapper.__doc__ = (
+            f"Synchronous version of {async_func.__name__}.\n\n{async_func.__doc__}"
+        )
+
+    # Attach the sync version as an attribute
+    async_func.sync = sync_wrapper
+
+    # Return the original async function
+    return async_func

tunacode/ui/input.py

@@ -0,0 +1,95 @@
+"""User input handling functions for Sidekick UI."""
+
+from typing import Optional
+
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.styles import Style
+from prompt_toolkit.validation import Validator
+
+from tunacode.constants import UI_COLORS, UI_PROMPT_PREFIX
+from tunacode.core.state import StateManager
+
+from .completers import create_completer
+from .keybindings import create_key_bindings
+from .lexers import FileReferenceLexer
+from .prompt_manager import PromptConfig, PromptManager
+
+
+def formatted_text(text: str) -> HTML:
+    """Create formatted HTML text."""
+    return HTML(text)
+
+
+async def input(
+    session_key: str,
+    pretext: str = UI_PROMPT_PREFIX,
+    is_password: bool = False,
+    validator: Optional[Validator] = None,
+    multiline: bool = False,
+    key_bindings: Optional[KeyBindings] = None,
+    placeholder: Optional[HTML] = None,
+    completer=None,
+    lexer=None,
+    timeoutlen: float = 0.05,
+    state_manager: Optional[StateManager] = None,
+) -> str:
+    """
+    Prompt for user input using simplified prompt management.
+
+    Args:
+        session_key: The session key for the prompt
+        pretext: The text to display before the input prompt
+        is_password: Whether to mask the input
+        validator: Optional input validator
+        multiline: Whether to allow multiline input
+        key_bindings: Optional custom key bindings
+        placeholder: Optional placeholder text
+        completer: Optional completer for tab completion
+        lexer: Optional lexer for syntax highlighting
+        timeoutlen: Timeout length for input
+        state_manager: The state manager for session storage
+
+    Returns:
+        User input string
+    """
+    # Create prompt configuration
+    config = PromptConfig(
+        multiline=multiline,
+        is_password=is_password,
+        validator=validator,
+        key_bindings=key_bindings,
+        placeholder=placeholder,
+        completer=completer,
+        lexer=lexer,
+        timeoutlen=timeoutlen,
+    )
+
+    # Create prompt manager
+    manager = PromptManager(state_manager)
+
+    # Get user input
+    return await manager.get_input(session_key, pretext, config)
+
+
+async def multiline_input(state_manager: Optional[StateManager] = None, command_registry=None) -> str:
+    """Get multiline input from the user with @file completion and highlighting."""
+    kb = create_key_bindings()
+    placeholder = formatted_text(
+        (
+            "<darkgrey>"
+            "<bold>Enter</bold> to submit, "
+            "<bold>Esc + Enter</bold> for new line, "
+            "<bold>/help</bold> for commands"
+            "</darkgrey>"
+        )
+    )
+    return await input(
+        "multiline", 
+        key_bindings=kb, 
+        multiline=True, 
+        placeholder=placeholder,
+        completer=create_completer(command_registry),
+        lexer=FileReferenceLexer(),
+        state_manager=state_manager
+    )

tunacode/ui/keybindings.py

@@ -0,0 +1,27 @@
+"""Key binding handlers for Sidekick UI."""
+
+from prompt_toolkit.key_binding import KeyBindings
+
+
+def create_key_bindings() -> KeyBindings:
+    """Create and configure key bindings for the UI."""
+    kb = KeyBindings()
+
+    
+
+    @kb.add("enter")
+    def _submit(event):
+        """Submit the current buffer."""
+        event.current_buffer.validate_and_handle()
+
+    @kb.add("c-o")  # ctrl+o
+    def _newline(event):
+        """Insert a newline character."""
+        event.current_buffer.insert_text("\n")
+    
+    @kb.add("escape", "enter")
+    def _escape_enter(event):
+        """Insert a newline when escape then enter is pressed."""
+        event.current_buffer.insert_text("\n")
+
+    return kb

tunacode/ui/lexers.py

@@ -0,0 +1,46 @@
+"""Custom lexers for syntax highlighting in the CLI."""
+
+import re
+
+from prompt_toolkit.formatted_text import FormattedText
+from prompt_toolkit.lexers import Lexer
+
+
+class FileReferenceLexer(Lexer):
+    """Lexer that highlights @file references in light blue."""
+    
+    # Pattern to match @file references
+    FILE_REF_PATTERN = re.compile(r'@([\w./_-]+)')
+    
+    def lex_document(self, document):
+        """Return a formatted text list for the given document."""
+        lines = document.text.split('\n')
+        
+        def get_line_tokens(line_number):
+            """Get tokens for a specific line."""
+            if line_number >= len(lines):
+                return []
+                
+            line = lines[line_number]
+            tokens = []
+            last_end = 0
+            
+            # Find all @file references in the line
+            for match in self.FILE_REF_PATTERN.finditer(line):
+                start, end = match.span()
+                
+                # Add text before the match
+                if start > last_end:
+                    tokens.append(('', line[last_end:start]))
+                
+                # Add the @file reference with styling
+                tokens.append(('class:file-reference', match.group(0)))
+                last_end = end
+            
+            # Add remaining text
+            if last_end < len(line):
+                tokens.append(('', line[last_end:]))
+                
+            return tokens
+        
+        return get_line_tokens

tunacode/ui/output.py

@@ -0,0 +1,109 @@
+"""Output and display functions for Sidekick UI."""
+
+from prompt_toolkit.application import run_in_terminal
+from rich.console import Console
+from rich.padding import Padding
+
+from tunacode.configuration.settings import ApplicationSettings
+from tunacode.constants import (MSG_UPDATE_AVAILABLE, MSG_UPDATE_INSTRUCTION, MSG_VERSION_DISPLAY,
+                                UI_COLORS, UI_THINKING_MESSAGE)
+from tunacode.core.state import StateManager
+from tunacode.utils.file_utils import DotDict
+
+from .constants import SPINNER_TYPE
+from .decorators import create_sync_wrapper
+
+console = Console()
+colors = DotDict(UI_COLORS)
+
+BANNER = """[bold #00d7ff]┌─────────────────────────────────────────────────────────────────┐[/bold #00d7ff]
+[bold #00d7ff]│[/bold #00d7ff] [bold white]T U N A C O D E[/bold white] [dim #64748b]• Agentic AI Development Environment[/dim #64748b] [bold #00d7ff]│[/bold #00d7ff]
+[bold #00d7ff]└─────────────────────────────────────────────────────────────────┘[/bold #00d7ff]"""
+
+
+@create_sync_wrapper
+async def print(message, **kwargs) -> None:
+    """Print a message to the console."""
+    await run_in_terminal(lambda: console.print(message, **kwargs))
+
+
+async def line() -> None:
+    """Print a line to the console."""
+    await run_in_terminal(lambda: console.line())
+
+
+async def info(text: str) -> None:
+    """Print an informational message."""
+    await print(f"[{colors.primary}]●[/{colors.primary}] {text}", style=colors.muted)
+
+
+async def success(message: str) -> None:
+    """Print a success message."""
+    await print(f"[{colors.success}]✓[/{colors.success}] {message}")
+
+
+async def warning(text: str) -> None:
+    """Print a warning message."""
+    await print(f"[{colors.warning}]⚠[/{colors.warning}] {text}")
+
+
+async def muted(text: str, spaces: int = 0) -> None:
+    """Print a muted message."""
+    await print(f"{' ' * spaces}[{colors.muted}]•[/{colors.muted}] [dim]{text}[/dim]")
+
+
+async def usage(usage: str) -> None:
+    """Print usage information."""
+    await print(Padding(usage, (0, 0, 1, 2)), style=colors.muted)
+
+
+async def version() -> None:
+    """Print version information."""
+    app_settings = ApplicationSettings()
+    await info(MSG_VERSION_DISPLAY.format(version=app_settings.version))
+
+
+async def banner() -> None:
+    """Display the application banner."""
+    console.clear()
+    banner_padding = Padding(BANNER, (2, 0, 1, 0))
+    await print(banner_padding)
+
+
+async def clear() -> None:
+    """Clear the console and display the banner."""
+    console.clear()
+    await banner()
+
+
+async def update_available(latest_version: str) -> None:
+    """Display update available notification."""
+    await warning(MSG_UPDATE_AVAILABLE.format(latest_version=latest_version))
+    await muted(MSG_UPDATE_INSTRUCTION)
+
+
+async def spinner(show: bool = True, spinner_obj=None, state_manager: StateManager = None):
+    """Manage a spinner display."""
+    icon = SPINNER_TYPE
+    message = UI_THINKING_MESSAGE
+
+    # Get spinner from state manager if available
+    if spinner_obj is None and state_manager:
+        spinner_obj = state_manager.session.spinner
+
+    if not spinner_obj:
+        spinner_obj = await run_in_terminal(lambda: console.status(message, spinner=icon))
+        # Store it back in state manager if available
+        if state_manager:
+            state_manager.session.spinner = spinner_obj
+
+    if show:
+        spinner_obj.start()
+    else:
+        spinner_obj.stop()
+
+    return spinner_obj
+
+
+# Auto-generated sync version
+sync_print = print.sync  # type: ignore

tunacode/ui/panels.py

@@ -0,0 +1,156 @@
+"""Panel display functions for Sidekick UI."""
+
+from typing import Any, Optional, Union
+
+from rich.markdown import Markdown
+from rich.padding import Padding
+from rich.panel import Panel
+from rich.pretty import Pretty
+from rich.table import Table
+
+from tunacode.configuration.models import ModelRegistry
+from tunacode.constants import (APP_NAME, CMD_CLEAR, CMD_COMPACT, CMD_DUMP, CMD_EXIT, CMD_HELP,
+                                CMD_MODEL, CMD_UNDO, CMD_YOLO, DESC_CLEAR, DESC_COMPACT, DESC_DUMP,
+                                DESC_EXIT, DESC_HELP, DESC_MODEL, DESC_MODEL_DEFAULT,
+                                DESC_MODEL_SWITCH, DESC_UNDO, DESC_YOLO, PANEL_AVAILABLE_COMMANDS,
+                                PANEL_ERROR, PANEL_MESSAGE_HISTORY, PANEL_MODELS, UI_COLORS)
+from tunacode.core.state import StateManager
+from tunacode.utils.file_utils import DotDict
+
+from .constants import DEFAULT_PANEL_PADDING
+from .decorators import create_sync_wrapper
+from .output import print
+
+colors = DotDict(UI_COLORS)
+
+
+@create_sync_wrapper
+async def panel(
+    title: str,
+    text: Union[str, Markdown, Pretty],
+    top: int = DEFAULT_PANEL_PADDING["top"],
+    right: int = DEFAULT_PANEL_PADDING["right"],
+    bottom: int = DEFAULT_PANEL_PADDING["bottom"],
+    left: int = DEFAULT_PANEL_PADDING["left"],
+    border_style: Optional[str] = None,
+    **kwargs: Any,
+) -> None:
+    """Display a rich panel with modern styling."""
+    border_style = border_style or kwargs.get("style") or colors.border
+    panel_obj = Panel(
+        Padding(text, (0, 1, 0, 1)), 
+        title=f"[bold]{title}[/bold]", 
+        title_align="left", 
+        border_style=border_style,
+        padding=(0, 1)
+    )
+    await print(Padding(panel_obj, (top, right, bottom, left)), **kwargs)
+
+
+async def agent(text: str, bottom: int = 1) -> None:
+    """Display an agent panel with modern styling."""
+    title = f"[bold {colors.primary}]●[/bold {colors.primary}] {APP_NAME}"
+    await panel(title, Markdown(text), bottom=bottom, border_style=colors.primary)
+
+
+async def error(text: str) -> None:
+    """Display an error panel."""
+    await panel(PANEL_ERROR, text, style=colors.error)
+
+
+async def dump_messages(messages_list=None, state_manager: StateManager = None) -> None:
+    """Display message history panel."""
+    if messages_list is None and state_manager:
+        # Get messages from state manager
+        messages = Pretty(state_manager.session.messages)
+    elif messages_list is not None:
+        messages = Pretty(messages_list)
+    else:
+        # No messages available
+        messages = Pretty([])
+    await panel(PANEL_MESSAGE_HISTORY, messages, style=colors.muted)
+
+
+async def models(state_manager: StateManager = None) -> None:
+    """Display available models panel."""
+    model_registry = ModelRegistry()
+    model_ids = list(model_registry.list_models().keys())
+    model_list = "\n".join([f"{index} - {model}" for index, model in enumerate(model_ids)])
+    current_model = state_manager.session.current_model if state_manager else "unknown"
+    text = f"Current model: {current_model}\n\n{model_list}"
+    await panel(PANEL_MODELS, text, border_style=colors.muted)
+
+
+async def help(command_registry=None) -> None:
+    """Display the available commands organized by category."""
+    table = Table(show_header=False, box=None, padding=(0, 3, 0, 0))
+    table.add_column("Command", style=f"bold {colors.primary}", justify="right", min_width=16)
+    table.add_column("Description", style=colors.muted)
+
+    if command_registry:
+        # Use the new command registry to display commands by category
+        from ..cli.commands import CommandCategory
+
+        category_order = [
+            CommandCategory.SYSTEM,
+            CommandCategory.NAVIGATION,
+            CommandCategory.DEVELOPMENT,
+            CommandCategory.MODEL,
+            CommandCategory.DEBUG,
+        ]
+
+        for category in category_order:
+            commands = command_registry.get_commands_by_category(category)
+            if commands:
+                # Add category header
+                table.add_row("", "")
+                table.add_row(f"[bold]{category.value.title()}[/bold]", "")
+
+                # Add commands in this category
+                for command in commands:
+                    # Show primary command name
+                    cmd_display = f"/{command.name}"
+                    table.add_row(cmd_display, command.description)
+
+                    # Special handling for model command variations
+                    if command.name == "model":
+                        table.add_row(f"{cmd_display} <n>", DESC_MODEL_SWITCH)
+                        table.add_row(f"{cmd_display} <n> default", DESC_MODEL_DEFAULT)
+
+        # Add built-in commands
+        table.add_row("", "")
+        table.add_row("[bold]Built-in[/bold]", "")
+        table.add_row(CMD_EXIT, DESC_EXIT)
+    else:
+        # Fallback to static command list
+        commands = [
+            (CMD_HELP, DESC_HELP),
+            (CMD_CLEAR, DESC_CLEAR),
+            (CMD_DUMP, DESC_DUMP),
+            (CMD_YOLO, DESC_YOLO),
+            (CMD_UNDO, DESC_UNDO),
+            (CMD_COMPACT, DESC_COMPACT),
+            (CMD_MODEL, DESC_MODEL),
+            (f"{CMD_MODEL} <n>", DESC_MODEL_SWITCH),
+            (f"{CMD_MODEL} <n> default", DESC_MODEL_DEFAULT),
+            (CMD_EXIT, DESC_EXIT),
+        ]
+
+        for cmd, desc in commands:
+            table.add_row(cmd, desc)
+
+    await panel(PANEL_AVAILABLE_COMMANDS, table, border_style=colors.muted)
+
+
+@create_sync_wrapper
+async def tool_confirm(
+    title: str, content: Union[str, Markdown], filepath: Optional[str] = None
+) -> None:
+    """Display a tool confirmation panel."""
+    bottom_padding = 0 if filepath else 1
+    await panel(title, content, bottom=bottom_padding, border_style=colors.warning)
+
+
+# Auto-generated sync versions
+sync_panel = panel.sync  # type: ignore
+sync_tool_confirm = tool_confirm.sync  # type: ignore