alita-sdk 0.3.379__py3-none-any.whl → 0.3.627__py3-none-any.whl

alita_sdk/cli/formatting.py

@@ -0,0 +1,182 @@
+"""
+Output formatting utilities for Alita CLI.
+
+Provides text and JSON formatters for displaying toolkit test results,
+agent responses, and other CLI outputs.
+"""
+
+import json
+from typing import Any, Dict, List, Optional
+from datetime import datetime
+
+
+class OutputFormatter:
+    """Base class for output formatters."""
+    
+    def format_toolkit_result(self, result: Dict[str, Any]) -> str:
+        """Format toolkit test result."""
+        raise NotImplementedError
+    
+    def format_error(self, error: str) -> str:
+        """Format error message."""
+        raise NotImplementedError
+    
+    def format_toolkit_list(self, toolkits: List[Dict[str, Any]]) -> str:
+        """Format list of available toolkits."""
+        raise NotImplementedError
+
+
+class TextFormatter(OutputFormatter):
+    """Human-readable text formatter."""
+    
+    def format_toolkit_result(self, result: Dict[str, Any]) -> str:
+        """Format toolkit test result as text."""
+        if not result.get('success', False):
+            return self.format_error(result.get('error', 'Unknown error'))
+        
+        lines = [
+            "\n✓ Tool executed successfully\n",
+            f"Tool: {result.get('tool_name', 'unknown')}",
+            f"Toolkit: {result.get('toolkit_config', {}).get('type', 'unknown')}",
+            f"LLM Model: {result.get('llm_model', 'N/A')}",
+            f"Execution time: {result.get('execution_time_seconds', 0):.3f}s",
+            "",
+            "Result:",
+        ]
+        
+        # Format result based on type
+        tool_result = result.get('result')
+        if isinstance(tool_result, str):
+            lines.append(f"  {tool_result}")
+        elif isinstance(tool_result, dict):
+            for key, value in tool_result.items():
+                lines.append(f"  {key}: {value}")
+        else:
+            lines.append(f"  {str(tool_result)}")
+        
+        # Add events if present
+        events = result.get('events_dispatched', [])
+        if events:
+            lines.extend([
+                "",
+                f"Events dispatched: {len(events)}"
+            ])
+            for event in events[:5]:  # Limit to first 5 events
+                event_data = event.get('data', {})
+                message = event_data.get('message', str(event_data))
+                lines.append(f"  - {event.get('name', 'event')}: {message}")
+            
+            if len(events) > 5:
+                lines.append(f"  ... and {len(events) - 5} more events")
+        
+        return "\n".join(lines)
+    
+    def format_error(self, error: str) -> str:
+        """Format error message as text."""
+        return f"\n✗ Error: {error}\n"
+    
+    def format_toolkit_list(self, toolkits: List[Dict[str, Any]]) -> str:
+        """Format list of available toolkits as text."""
+        lines = ["\nAvailable toolkits:\n"]
+        
+        for toolkit in sorted(toolkits, key=lambda x: x.get('name', '')):
+            name = toolkit.get('name', 'unknown')
+            class_name = toolkit.get('class_name', '')
+            lines.append(f"  - {name}" + (f" ({class_name})" if class_name else ""))
+        
+        lines.append(f"\nTotal: {len(toolkits)} toolkits")
+        return "\n".join(lines)
+    
+    def format_toolkit_schema(self, toolkit_name: str, schema: Dict[str, Any]) -> str:
+        """Format toolkit schema as text."""
+        lines = [
+            f"\n{toolkit_name.title()} Toolkit Configuration Schema:\n",
+        ]
+        
+        properties = schema.get('properties', {})
+        required = schema.get('required', [])
+        
+        for field_name, field_schema in properties.items():
+            field_type = field_schema.get('type', 'any')
+            description = field_schema.get('description', '')
+            is_required = field_name in required
+            default = field_schema.get('default')
+            
+            req_text = "required" if is_required else "optional"
+            lines.append(f"  - {field_name} ({req_text}): {description}")
+            lines.append(f"      Type: {field_type}")
+            
+            if default is not None:
+                lines.append(f"      Default: {default}")
+            
+            # Show enum values if present
+            if 'enum' in field_schema:
+                lines.append(f"      Options: {', '.join(map(str, field_schema['enum']))}")
+            
+            # Handle nested objects
+            if field_type == 'object' and 'properties' in field_schema:
+                lines.append(f"      Fields:")
+                for nested_name, nested_schema in field_schema['properties'].items():
+                    nested_desc = nested_schema.get('description', '')
+                    lines.append(f"        - {nested_name}: {nested_desc}")
+            
+            lines.append("")
+        
+        return "\n".join(lines)
+
+
+class JSONFormatter(OutputFormatter):
+    """JSON formatter for scripting and automation."""
+    
+    def __init__(self, pretty: bool = True):
+        """
+        Initialize JSON formatter.
+        
+        Args:
+            pretty: If True, format JSON with indentation
+        """
+        self.pretty = pretty
+    
+    def _dump(self, data: Any) -> str:
+        """Dump data as JSON."""
+        if self.pretty:
+            return json.dumps(data, indent=2, default=str)
+        return json.dumps(data, default=str)
+    
+    def format_toolkit_result(self, result: Dict[str, Any]) -> str:
+        """Format toolkit test result as JSON."""
+        return self._dump(result)
+    
+    def format_error(self, error: str) -> str:
+        """Format error message as JSON."""
+        return self._dump({'success': False, 'error': error})
+    
+    def format_toolkit_list(self, toolkits: List[Dict[str, Any]]) -> str:
+        """Format list of available toolkits as JSON."""
+        return self._dump({
+            'toolkits': toolkits,
+            'total': len(toolkits)
+        })
+    
+    def format_toolkit_schema(self, toolkit_name: str, schema: Dict[str, Any]) -> str:
+        """Format toolkit schema as JSON."""
+        return self._dump({
+            'toolkit': toolkit_name,
+            'schema': schema
+        })
+
+
+def get_formatter(output_format: str = 'text', pretty: bool = True) -> OutputFormatter:
+    """
+    Get output formatter by name.
+    
+    Args:
+        output_format: Format type ('text' or 'json')
+        pretty: For JSON formatter, whether to pretty-print
+        
+    Returns:
+        OutputFormatter instance
+    """
+    if output_format == 'json':
+        return JSONFormatter(pretty=pretty)
+    return TextFormatter()

alita_sdk/cli/input_handler.py

@@ -0,0 +1,419 @@
+"""
+Enhanced input handler with readline support.
+
+Provides tab completion for commands, cursor movement, and input history.
+"""
+
+import readline
+import os
+from pathlib import Path
+from typing import Dict, List, Optional, Any, Callable
+
+from rich.console import Console
+from rich.text import Text
+
+console = Console()
+
+# Available commands for autocompletion
+CHAT_COMMANDS = [
+    '/help',
+    '/clear',
+    '/history', 
+    '/save',
+    '/agent',
+    '/model',
+    '/mode',
+    '/mode always',
+    '/mode auto',
+    '/mode yolo',
+    '/dir',
+    '/dir add',
+    '/dir rm',
+    '/dir remove',
+    '/inventory',
+    '/session',
+    '/session list',
+    '/session resume',
+    '/add_mcp',
+    '/add_toolkit',
+    '/rm_mcp',
+    '/rm_toolkit',
+    '/reload',
+    'exit',
+    'quit',
+]
+
+
+# Callback to get dynamic toolkit names for completion
+_toolkit_names_callback: Optional[Callable[[], List[str]]] = None
+
+# Callback to get inventory .json files for completion
+_inventory_files_callback: Optional[Callable[[], List[str]]] = None
+
+
+def set_toolkit_names_callback(callback: Callable[[], List[str]]):
+    """
+    Set a callback function that returns available toolkit names.
+    
+    This allows the input handler to provide dynamic completions
+    for /add_toolkit without having a direct dependency on config.
+    """
+    global _toolkit_names_callback
+    _toolkit_names_callback = callback
+
+
+def set_inventory_files_callback(callback: Callable[[], List[str]]):
+    """
+    Set a callback function that returns available inventory .json files.
+    
+    This allows the input handler to provide dynamic completions
+    for /inventory without having a direct dependency on agents.py.
+    """
+    global _inventory_files_callback
+    _inventory_files_callback = callback
+
+
+def get_toolkit_names_for_completion() -> List[str]:
+    """Get toolkit names for tab completion."""
+    global _toolkit_names_callback
+    if _toolkit_names_callback:
+        try:
+            return _toolkit_names_callback()
+        except Exception:
+            return []
+    return []
+
+
+def get_inventory_files_for_completion() -> List[str]:
+    """Get inventory .json files for tab completion."""
+    global _inventory_files_callback
+    if _inventory_files_callback:
+        try:
+            return _inventory_files_callback()
+        except Exception:
+            return []
+    return []
+
+
+class ChatInputHandler:
+    """
+    Enhanced input handler with readline support for chat sessions.
+    
+    Features:
+    - Tab completion for slash commands
+    - Arrow key navigation through input history
+    - Cursor movement with left/right arrows
+    - Ctrl+A (start of line), Ctrl+E (end of line)
+    - Persistent command history within session
+    - Material UI-style input prompt
+    """
+    
+    def __init__(self):
+        self._setup_readline()
+        self._input_history: List[str] = []
+    
+    def _setup_readline(self):
+        """Configure readline for enhanced input."""
+        # Set up tab completion
+        readline.set_completer(self._completer)
+        
+        # Detect if we're using libedit (macOS) or GNU readline (Linux)
+        # libedit uses different syntax for parse_and_bind
+        if 'libedit' in readline.__doc__:
+            # macOS libedit syntax
+            readline.parse_and_bind('bind ^I rl_complete')
+        else:
+            # GNU readline syntax
+            readline.parse_and_bind('tab: complete')
+        
+        # Enable emacs-style keybindings (Ctrl+A, Ctrl+E, etc.)
+        # This is usually the default on macOS/Linux
+        try:
+            if 'libedit' not in readline.__doc__:
+                readline.parse_and_bind('set editing-mode emacs')
+        except Exception:
+            pass  # Some systems might not support this
+        
+        # Set completion display style (GNU readline only)
+        try:
+            if 'libedit' not in readline.__doc__:
+                readline.parse_and_bind('set show-all-if-ambiguous on')
+                readline.parse_and_bind('set completion-ignore-case on')
+        except Exception:
+            pass
+        
+        # Set delimiters for completion (space and common punctuation)
+        readline.set_completer_delims(' \t\n;')
+    
+    def _completer(self, text: str, state: int) -> Optional[str]:
+        """
+        Readline completer function for slash commands.
+        
+        Args:
+            text: The current text being completed
+            state: The state of completion (0 for first match, 1 for second, etc.)
+            
+        Returns:
+            The next matching command or None
+        """
+        # Get the full line buffer
+        line = readline.get_line_buffer()
+        
+        # Only complete at the start of the line or after whitespace
+        if line and not line.startswith('/') and text != line:
+            return None
+        
+        matches = []
+        
+        # Handle /add_toolkit <name> completion
+        if line.startswith('/add_toolkit '):
+            # Get partial toolkit name being typed
+            toolkit_prefix = text.lower()
+            toolkit_names = get_toolkit_names_for_completion()
+            matches = [f'/add_toolkit {name}' for name in toolkit_names 
+                      if name.lower().startswith(toolkit_prefix) or toolkit_prefix == '']
+            # Also match just the toolkit name if text doesn't start with /
+            if not text.startswith('/'):
+                matches = [name for name in toolkit_names if name.lower().startswith(toolkit_prefix)]
+        # Handle /inventory <path> completion
+        elif line.startswith('/inventory '):
+            # Get partial path being typed
+            path_prefix = text.lower()
+            inventory_files = get_inventory_files_for_completion()
+            matches = [f'/inventory {path}' for path in inventory_files 
+                      if path.lower().startswith(path_prefix) or path_prefix == '']
+            # Also match just the path if text doesn't start with /
+            if not text.startswith('/'):
+                matches = [path for path in inventory_files if path.lower().startswith(path_prefix)]
+        # Find matching commands
+        elif text.startswith('/'):
+            matches = [cmd for cmd in CHAT_COMMANDS if cmd.startswith(text)]
+        elif text == '' and line == '':
+            # Show all commands on empty tab
+            matches = [cmd for cmd in CHAT_COMMANDS if cmd.startswith('/')]
+        else:
+            matches = [cmd for cmd in CHAT_COMMANDS if cmd.startswith(text)]
+        
+        # Return the match at the given state
+        if state < len(matches):
+            return matches[state]
+        return None
+    
+    def get_input(self, prompt: str = "") -> str:
+        """
+        Get user input with enhanced readline features.
+        
+        Args:
+            prompt: The prompt to display (note: for rich console, prompt is printed separately)
+            
+        Returns:
+            The user's input string
+        """
+        try:
+            user_input = input(prompt)
+            
+            # Add non-empty, non-duplicate inputs to history
+            if user_input.strip() and (not self._input_history or 
+                                        self._input_history[-1] != user_input):
+                self._input_history.append(user_input)
+                readline.add_history(user_input)
+            
+            return user_input
+        except (KeyboardInterrupt, EOFError):
+            raise
+    
+    def clear_history(self):
+        """Clear the input history."""
+        self._input_history.clear()
+        readline.clear_history()
+    
+    @property
+    def history(self) -> List[str]:
+        """Get the current input history."""
+        return self._input_history.copy()
+
+
+# Global instance for use across the CLI
+_input_handler: Optional[ChatInputHandler] = None
+
+
+def get_input_handler() -> ChatInputHandler:
+    """Get or create the global input handler instance."""
+    global _input_handler
+    if _input_handler is None:
+        _input_handler = ChatInputHandler()
+    return _input_handler
+
+
+def chat_input(prompt: str = "") -> str:
+    """
+    Convenience function for getting chat input with enhanced features.
+    
+    Args:
+        prompt: The prompt to display
+        
+    Returns:
+        The user's input string
+    """
+    return get_input_handler().get_input(prompt)
+
+
+def styled_input(context_info: Optional[Dict[str, Any]] = None) -> str:
+    """
+    Get user input with a styled bordered prompt that works correctly with readline.
+    
+    The prompt is passed directly to input() so readline can properly
+    handle cursor positioning and history navigation.
+    
+    Args:
+        context_info: Optional context info dict with keys:
+            - used_tokens: Current tokens in context
+            - max_tokens: Maximum allowed tokens
+            - fill_ratio: Context fill ratio (0.0-1.0)
+            - pruned_count: Number of pruned messages
+    
+    Returns:
+        The user's input string
+    """
+    # Get terminal width for the border
+    try:
+        width = console.width - 2
+    except Exception:
+        width = 78
+    
+    # Build context indicator if provided
+    context_indicator = ""
+    if context_info and context_info.get('max_tokens', 0) > 0:
+        context_indicator = _format_context_indicator(
+            context_info.get('used_tokens', 0),
+            context_info.get('max_tokens', 8000),
+            context_info.get('fill_ratio', 0.0),
+            context_info.get('pruned_count', 0),
+        )
+    
+    # Print the complete box frame first, then move cursor up to input line
+    console.print()
+    console.print(f"[dim]╭{'─' * width}╮[/dim]")
+    console.print(f"[dim]│[/dim]{' ' * width}[dim]│[/dim]")
+    
+    # Bottom border with context indicator on the right
+    if context_indicator:
+        indicator_len = len(_strip_ansi(context_indicator))
+        padding = width - indicator_len - 1
+        console.print(f"[dim]╰{'─' * padding}[/dim]{context_indicator}[dim]─╯[/dim]")
+    else:
+        console.print(f"[dim]╰{'─' * width}╯[/dim]")
+    
+    # Move cursor up 2 lines and to position after "│ > "
+    # \033[2A = move up 2 lines, \033[4C = move right 4 columns
+    prompt = "\033[2A\033[2C > "
+    
+    user_input = get_input_handler().get_input(prompt)
+    
+    # Move cursor down to after the box
+    console.print()
+    
+    return user_input
+
+
+def _format_context_indicator(
+    used_tokens: int,
+    max_tokens: int,
+    fill_ratio: float,
+    pruned_count: int = 0
+) -> str:
+    """
+    Format context usage indicator for display.
+    
+    Shows: [1234/8000 ██████░░░░ 15%]
+    Color coded: green <70%, yellow 70-90%, red >90%
+    
+    Args:
+        used_tokens: Current tokens in context
+        max_tokens: Maximum allowed tokens
+        fill_ratio: Context fill ratio (0.0-1.0)
+        pruned_count: Number of pruned messages
+        
+    Returns:
+        Formatted indicator string with ANSI colors
+    """
+    # Determine color based on fill ratio
+    if fill_ratio < 0.7:
+        color = "green"
+    elif fill_ratio < 0.9:
+        color = "yellow"
+    else:
+        color = "red"
+    
+    # Build progress bar (10 chars)
+    bar_width = 10
+    filled = int(fill_ratio * bar_width)
+    empty = bar_width - filled
+    bar = "█" * filled + "░" * empty
+    
+    # Format percentage
+    percent = int(fill_ratio * 100)
+    
+    # Build indicator
+    indicator = f"[{color}]{used_tokens}/{max_tokens} {bar} {percent}%[/{color}]"
+    
+    # Add pruned count if any
+    if pruned_count > 0:
+        indicator += f" [dim]({pruned_count} pruned)[/dim]"
+    
+    return indicator
+
+
+def _strip_ansi(text: str) -> str:
+    """Strip ANSI escape codes and Rich markup from text for length calculation."""
+    import re
+    # Remove Rich markup tags like [green], [/green], [dim], etc.
+    text = re.sub(r'\[/?[^\]]+\]', '', text)
+    # Remove ANSI escape codes
+    text = re.sub(r'\x1b\[[0-9;]*m', '', text)
+    return text
+
+
+def styled_selection_input(prompt_text: str = "Select") -> str:
+    """
+    Get user selection input with a styled bordered prompt.
+    
+    Args:
+        prompt_text: The prompt text to show (e.g., "Select model number")
+        
+    Returns:
+        The user's input string
+    """
+    # Get terminal width for the border
+    try:
+        width = console.width - 2
+    except Exception:
+        width = 78
+    
+    # Print the complete box frame first, then move cursor up to input line
+    console.print()
+    console.print(f"[dim]╭{'─' * width}╮[/dim]")
+    console.print(f"[dim]│[/dim]{' ' * width}[dim]│[/dim]")
+    console.print(f"[dim]╰{'─' * width}╯[/dim]")
+    
+    # Move cursor up 2 lines and to position after "│"
+    # \033[2A = move up 2 lines, \033[2C = move right 2 columns
+    prompt = f"\033[2A\033[2C {prompt_text}: "
+    
+    try:
+        user_input = input(prompt)
+    except (KeyboardInterrupt, EOFError):
+        console.print()
+        raise
+    
+    # Move cursor down to after the box
+    console.print()
+    
+    return user_input.strip()
+
+
+def print_input_prompt():
+    """Print a clean, modern input prompt."""
+    # Simple clean prompt with > indicator
+    console.print()  # Empty line for spacing
+    console.print("[bold cyan]>[/bold cyan] ", end="")