alita-sdk 0.3.365__py3-none-any.whl → 0.3.462__py3-none-any.whl

alita_sdk/cli/cli.py

@@ -0,0 +1,159 @@
+"""
+Main CLI application for Alita SDK.
+
+Provides command-line interface for testing agents and toolkits,
+using the same .env authentication as SDK tests and Streamlit interface.
+"""
+
+# Suppress warnings FIRST before any other imports
+import warnings
+warnings.filterwarnings('ignore', category=DeprecationWarning)
+warnings.filterwarnings('ignore', category=UserWarning)
+warnings.filterwarnings('ignore', message='Unverified HTTPS request')
+
+import click
+import logging
+import sys
+from typing import Optional
+
+from .config import get_config
+from .formatting import get_formatter
+
+# Configure logging
+logging.basicConfig(
+    level=logging.WARNING,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+@click.group()
+@click.option('--env-file', default='.env', help='Path to .env file')
+@click.option('--debug', is_flag=True, help='Enable debug logging')
+@click.option('--output', type=click.Choice(['text', 'json']), default='text', 
+              help='Output format')
+@click.pass_context
+def cli(ctx, env_file: str, debug: bool, output: str):
+    """
+    Alita SDK CLI - Test agents and toolkits from the command line.
+    
+    Credentials are loaded from .env file with variables:
+    - DEPLOYMENT_URL: Alita deployment URL
+    - PROJECT_ID: Project ID
+    - API_KEY: API authentication key
+    
+    Example .env file:
+    
+        DEPLOYMENT_URL=https://api.elitea.ai
+        PROJECT_ID=123
+        API_KEY=your_api_key_here
+    """
+    ctx.ensure_object(dict)
+    
+    # Enable debug logging if requested
+    if debug:
+        logging.getLogger('alita_sdk').setLevel(logging.DEBUG)
+        logger.setLevel(logging.DEBUG)
+        logger.debug("Debug logging enabled")
+    
+    # Load configuration
+    config = get_config(env_file=env_file)
+    ctx.obj['config'] = config
+    ctx.obj['formatter'] = get_formatter(output)
+    ctx.obj['debug'] = debug
+    
+    # Check if configuration is valid (but don't fail yet - some commands don't need it)
+    if not config.is_configured():
+        missing = config.get_missing_config()
+        ctx.obj['config_error'] = f"Missing required configuration: {', '.join(missing)}"
+        logger.debug(f"Configuration incomplete: {missing}")
+    else:
+        ctx.obj['config_error'] = None
+        logger.debug(f"Configuration loaded from {env_file}")
+
+
+def get_client(ctx):
+    """
+    Get configured AlitaClient from context.
+    
+    Raises click.ClickException if configuration is invalid.
+    """
+    if ctx.obj.get('config_error'):
+        raise click.ClickException(
+            f"{ctx.obj['config_error']}\n\n"
+            "Please ensure your .env file contains:\n"
+            "  DEPLOYMENT_URL=https://api.elitea.ai\n"
+            "  PROJECT_ID=123\n"
+            "  API_KEY=your_api_key_here"
+        )
+    
+    # Import here to avoid loading SDK if not needed
+    from alita_sdk.runtime.clients.client import AlitaClient
+    
+    config = ctx.obj['config']
+    
+    try:
+        client = AlitaClient(
+            base_url=config.deployment_url,
+            project_id=config.project_id,
+            auth_token=config.api_key
+        )
+        logger.debug(f"AlitaClient initialized for project {config.project_id}")
+        return client
+    except Exception as e:
+        raise click.ClickException(f"Failed to initialize AlitaClient: {str(e)}")
+
+
+@cli.command()
+@click.pass_context
+def config(ctx):
+    """Show current configuration (credentials masked)."""
+    config_obj = ctx.obj['config']
+    formatter = ctx.obj['formatter']
+    
+    if formatter.__class__.__name__ == 'JSONFormatter':
+        click.echo(formatter._dump(config_obj.to_dict()))
+    else:
+        click.echo("\nCurrent configuration:\n")
+        for key, value in config_obj.to_dict().items():
+            click.echo(f"  {key}: {value}")
+        
+        if not config_obj.is_configured():
+            missing = config_obj.get_missing_config()
+            click.echo(f"\n⚠ Missing: {', '.join(missing)}")
+        else:
+            click.echo("\n✓ Configuration is complete")
+
+
+# Import subcommands
+from . import toolkit
+from . import agents
+
+# Register subcommands
+cli.add_command(toolkit.toolkit)
+cli.add_command(agents.agent)
+
+# Add top-level 'chat' command as alias to 'agent chat'
+cli.add_command(agents.agent_chat, name='chat')
+
+
+def main():
+    """Entry point for CLI."""
+    # Suppress warnings at entry point
+    warnings.filterwarnings('ignore', category=DeprecationWarning)
+    warnings.filterwarnings('ignore', category=UserWarning)
+    warnings.filterwarnings('ignore', message='Unverified HTTPS request')
+    
+    try:
+        cli()
+    except KeyboardInterrupt:
+        click.echo("\n\nInterrupted by user", err=True)
+        sys.exit(130)
+    except Exception as e:
+        logger.exception("Unexpected error")
+        click.echo(f"\nError: {str(e)}", err=True)
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()

alita_sdk/cli/config.py

@@ -0,0 +1,153 @@
+"""
+Configuration management for Alita CLI.
+
+Loads credentials and settings from .env files using the same pattern
+as the SDK tests and Streamlit interface.
+"""
+
+import os
+import re
+from typing import Optional, Dict, Any
+from dotenv import load_dotenv
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class CLIConfig:
+    """Configuration manager for Alita CLI."""
+    
+    def __init__(self, env_file: Optional[str] = None):
+        """
+        Initialize CLI configuration.
+        
+        Args:
+            env_file: Path to .env file. If None, uses default (.env in current directory)
+        """
+        self.env_file = env_file or '.env'
+        self._load_env()
+        
+    def _load_env(self):
+        """Load environment variables from .env file."""
+        if os.path.exists(self.env_file):
+            load_dotenv(self.env_file)
+            logger.debug(f"Loaded environment from {self.env_file}")
+        else:
+            logger.debug(f"No .env file found at {self.env_file}, using system environment")
+    
+    @property
+    def deployment_url(self) -> Optional[str]:
+        """Get deployment URL from environment."""
+        return os.getenv('DEPLOYMENT_URL')
+    
+    @property
+    def project_id(self) -> Optional[int]:
+        """Get project ID from environment."""
+        try:
+            value = os.getenv('PROJECT_ID')
+            return int(value) if value else None
+        except (TypeError, ValueError):
+            return None
+    
+    @property
+    def api_key(self) -> Optional[str]:
+        """Get API key from environment."""
+        return os.getenv('API_KEY')
+    
+    @property
+    def alita_dir(self) -> str:
+        """Get Alita directory from environment (defaults to .alita)."""
+        return os.getenv('ALITA_DIR', '.alita')
+    
+    @property
+    def agents_dir(self) -> str:
+        """Get agents directory (derived from ALITA_DIR)."""
+        alita_agents = os.path.join(self.alita_dir, 'agents')
+        # Fallback to .github/agents if .alita/agents doesn't exist
+        if self.alita_dir == '.alita' and not os.path.exists(alita_agents):
+            if os.path.exists('.github/agents'):
+                return '.github/agents'
+        return alita_agents
+    
+    @property
+    def tools_dir(self) -> str:
+        """Get tools directory (derived from ALITA_DIR)."""
+        return os.path.join(self.alita_dir, 'tools')
+    
+    @property
+    def mcp_config_path(self) -> str:
+        """Get MCP configuration path (derived from ALITA_DIR)."""
+        alita_mcp = os.path.join(self.alita_dir, 'mcp.json')
+        # Fallback to mcp.json in current directory
+        if not os.path.exists(alita_mcp) and os.path.exists('mcp.json'):
+            return 'mcp.json'
+        return alita_mcp
+    
+    def is_configured(self) -> bool:
+        """Check if all required configuration is present."""
+        return all([
+            self.deployment_url,
+            self.project_id is not None,
+            self.api_key
+        ])
+    
+    def get_missing_config(self) -> list[str]:
+        """Get list of missing configuration items."""
+        missing = []
+        if not self.deployment_url:
+            missing.append('DEPLOYMENT_URL')
+        if self.project_id is None:
+            missing.append('PROJECT_ID')
+        if not self.api_key:
+            missing.append('API_KEY')
+        return missing
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert configuration to dictionary."""
+        return {
+            'deployment_url': self.deployment_url,
+            'project_id': self.project_id,
+            'api_key': '***' if self.api_key else None  # Masked for security
+        }
+
+
+def get_config(env_file: Optional[str] = None) -> CLIConfig:
+    """
+    Get CLI configuration instance.
+    
+    Args:
+        env_file: Optional path to .env file
+        
+    Returns:
+        CLIConfig instance
+    """
+    return CLIConfig(env_file=env_file)
+
+
+def substitute_env_vars(text: str) -> str:
+    """
+    Substitute environment variables in text.
+    
+    Supports both ${VAR} and $VAR syntax.
+    
+    Args:
+        text: Text containing environment variable references
+        
+    Returns:
+        Text with environment variables substituted
+    """
+    # Replace ${VAR} syntax
+    def replace_braced(match):
+        var_name = match.group(1)
+        return os.getenv(var_name, match.group(0))
+    
+    text = re.sub(r'\$\{([^}]+)\}', replace_braced, text)
+    
+    # Replace $VAR syntax (word boundaries)
+    def replace_simple(match):
+        var_name = match.group(1)
+        return os.getenv(var_name, match.group(0))
+    
+    text = re.sub(r'\$([A-Za-z_][A-Za-z0-9_]*)', replace_simple, text)
+    
+    return text

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()