alita-sdk 0.3.257__py3-none-any.whl → 0.3.584__py3-none-any.whl

alita_sdk/cli/cli.py

@@ -0,0 +1,168 @@
+"""
+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('--verbose', '-v', is_flag=True, help='Enable verbose/info logging (shows timing)')
+@click.option('--output', type=click.Choice(['text', 'json']), default='text', 
+              help='Output format')
+@click.pass_context
+def cli(ctx, env_file: str, debug: bool, verbose: 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")
+    elif verbose:
+        # Verbose mode shows INFO level (timing info)
+        logging.getLogger('alita_sdk').setLevel(logging.INFO)
+        logger.setLevel(logging.INFO)
+        logger.info("Verbose 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
+    ctx.obj['verbose'] = verbose
+    
+    # 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
+from . import inventory
+
+# Register subcommands
+cli.add_command(toolkit.toolkit)
+cli.add_command(agents.agent)
+cli.add_command(inventory.inventory)
+
+# 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,306 @@
+"""
+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
+import json
+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, checks ALITA_ENV_FILE env var,
+                      then falls back to .alita/.env or .env in current directory
+        """
+        self._config_json: Dict[str, Any] = {}
+        
+        if env_file:
+            self.env_file = env_file
+        else:
+            # Check ALITA_ENV_FILE environment variable first
+            alita_env_file = os.getenv('ALITA_ENV_FILE')
+            if alita_env_file:
+                # Expand ~ and resolve path
+                expanded_path = os.path.expanduser(alita_env_file)
+                if os.path.exists(expanded_path):
+                    self.env_file = expanded_path
+                else:
+                    logger.warning(f"ALITA_ENV_FILE set to {alita_env_file} but file not found")
+                    self.env_file = expanded_path  # Still use it, will warn later
+            elif os.path.exists(os.path.expanduser('~/.alita/.env')):
+                self.env_file = os.path.expanduser('~/.alita/.env')
+            elif os.path.exists('.alita/.env'):
+                self.env_file = '.alita/.env'
+            else:
+                self.env_file = '.env'
+        self._load_env()
+        self._load_config_json()
+        
+    def _load_env(self):
+        """Load environment variables from .env file."""
+        if os.path.exists(self.env_file):
+            # Use override=True to ensure .env values take precedence
+            load_dotenv(self.env_file, override=True)
+            logger.debug(f"Loaded environment from {self.env_file}")
+        else:
+            logger.debug(f"No .env file found at {self.env_file}, using system environment")
+    
+    def _load_config_json(self):
+        """Load configuration from $ALITA_DIR/config.json as fallback."""
+        # Try ALITA_DIR from env, then ~/.alita, then .alita
+        alita_dir = os.getenv('ALITA_DIR')
+        if alita_dir:
+            config_path = os.path.join(os.path.expanduser(alita_dir), 'config.json')
+        else:
+            # Try ~/.alita/config.json first, then .alita/config.json
+            home_config = os.path.expanduser('~/.alita/config.json')
+            local_config = '.alita/config.json'
+            if os.path.exists(home_config):
+                config_path = home_config
+            elif os.path.exists(local_config):
+                config_path = local_config
+            else:
+                config_path = home_config  # Default path even if doesn't exist
+        
+        if os.path.exists(config_path):
+            try:
+                with open(config_path, 'r') as f:
+                    self._config_json = json.load(f)
+                logger.debug(f"Loaded config from {config_path}")
+                
+                # Load env section into environment variables
+                self._load_env_section()
+            except (json.JSONDecodeError, IOError) as e:
+                logger.warning(f"Failed to load config.json: {e}")
+    
+    def _load_env_section(self):
+        """Load variables from config.json 'env' section into environment."""
+        env_vars = self._config_json.get('env', {})
+        if isinstance(env_vars, dict):
+            for key, value in env_vars.items():
+                # Only set if not already in environment (env vars take precedence)
+                if key not in os.environ and value is not None:
+                    os.environ[key] = str(value)
+                    logger.debug(f"Set {key} from config.json env section")
+    
+    def _get_config_value(self, env_key: str, json_key: Optional[str] = None) -> Optional[str]:
+        """
+        Get config value from environment first, then config.json fallback.
+        
+        Args:
+            env_key: Environment variable name
+            json_key: Key in config.json (defaults to lowercase of env_key)
+        """
+        # Try environment variable first
+        value = os.getenv(env_key)
+        if value:
+            return value
+        
+        # Fallback to config.json
+        if json_key is None:
+            json_key = env_key.lower()
+        
+        return self._config_json.get(json_key)
+    
+    @property
+    def deployment_url(self) -> Optional[str]:
+        """Get deployment URL from environment or config.json."""
+        return self._get_config_value('DEPLOYMENT_URL', 'deployment_url')
+    
+    @property
+    def project_id(self) -> Optional[int]:
+        """Get project ID from environment or config.json."""
+        try:
+            value = self._get_config_value('PROJECT_ID', '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 or config.json."""
+        return self._get_config_value('API_KEY', 'api_key')
+    
+    @property
+    def default_model(self) -> Optional[str]:
+        """Get default model from environment or config.json."""
+        return self._get_config_value('ALITA_DEFAULT_MODEL', 'default_model')
+    
+    @property
+    def default_temperature(self) -> Optional[float]:
+        """Get default temperature from environment or config.json."""
+        try:
+            value = self._get_config_value('ALITA_DEFAULT_TEMPERATURE', 'default_temperature')
+            return float(value) if value is not None else None
+        except (TypeError, ValueError):
+            return None
+    
+    @property
+    def default_max_tokens(self) -> Optional[int]:
+        """Get default max tokens from environment or config.json."""
+        try:
+            value = self._get_config_value('ALITA_DEFAULT_MAX_TOKENS', 'default_max_tokens')
+            return int(value) if value is not None else None
+        except (TypeError, ValueError):
+            return None
+    
+    @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
+    
+    @property
+    def context_management(self) -> Dict[str, Any]:
+        """
+        Get context management configuration from config.json.
+        
+        Returns configuration for chat history context management with defaults:
+        - enabled: True - Enable context management
+        - max_context_tokens: 8000 - Maximum tokens in context
+        - preserve_recent_messages: 5 - Always keep N most recent messages
+        - pruning_method: 'oldest_first' - Strategy for pruning (oldest_first, importance_based)
+        - enable_summarization: True - Generate summaries of pruned messages
+        - summary_trigger_ratio: 0.8 - Trigger summarization at 80% context fill
+        - summaries_limit_count: 5 - Maximum number of summaries to keep
+        - session_max_age_days: 30 - Purge sessions older than N days
+        - max_sessions: 50 - Maximum number of sessions to keep
+        """
+        defaults = {
+            'enabled': True,
+            'max_context_tokens': 8000,
+            'preserve_recent_messages': 5,
+            'pruning_method': 'oldest_first',
+            'enable_summarization': True,
+            'summary_trigger_ratio': 0.8,
+            'summaries_limit_count': 5,
+            'session_max_age_days': 30,
+            'max_sessions': 50,
+            'weights': {
+                'recency': 1.0,
+                'importance': 1.0,
+                'user_messages': 1.2,
+                'thread_continuity': 1.0,
+            },
+        }
+        
+        # Get from config.json
+        config = self._config_json.get('context_management', {})
+        
+        # Merge with defaults
+        result = defaults.copy()
+        if isinstance(config, dict):
+            result.update(config)
+        
+        return result
+    
+    @property
+    def sessions_dir(self) -> str:
+        """Get sessions directory (derived from ALITA_DIR)."""
+        return os.path.join(self.alita_dir, 'sessions')
+    
+    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/context/__init__.py

@@ -0,0 +1,30 @@
+"""
+Context management for CLI chat history.
+
+Provides token-aware context pruning, summarization, and session management
+to optimize LLM context usage during CLI conversations.
+"""
+
+from .manager import CLIContextManager, sanitize_message_history
+from .message import CLIMessage
+from .token_estimation import estimate_tokens, calculate_total_tokens
+from .strategies import (
+    PruningStrategy,
+    OldestFirstStrategy,
+    ImportanceBasedStrategy,
+    PruningStrategyFactory,
+)
+from .cleanup import purge_old_sessions
+
+__all__ = [
+    'CLIContextManager',
+    'CLIMessage',
+    'estimate_tokens',
+    'calculate_total_tokens',
+    'PruningStrategy',
+    'OldestFirstStrategy',
+    'ImportanceBasedStrategy',
+    'PruningStrategyFactory',
+    'purge_old_sessions',
+    'sanitize_message_history',
+]

alita_sdk/cli/context/cleanup.py

@@ -0,0 +1,198 @@
+"""
+Session cleanup utilities for CLI context management.
+
+Handles purging old sessions to prevent disk space issues.
+"""
+
+import os
+import shutil
+import logging
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+def get_sessions_dir(alita_dir: str = '.alita') -> Path:
+    """
+    Get the sessions directory path.
+    
+    Args:
+        alita_dir: Base Alita directory
+        
+    Returns:
+        Path to sessions directory
+    """
+    # Expand ~ for home directory
+    if alita_dir.startswith('~'):
+        alita_dir = os.path.expanduser(alita_dir)
+    return Path(alita_dir) / 'sessions'
+
+
+def list_sessions_with_age(alita_dir: str = '.alita') -> List[Tuple[str, float, datetime]]:
+    """
+    List all sessions with their age in days.
+    
+    Args:
+        alita_dir: Base Alita directory
+        
+    Returns:
+        List of tuples: (session_id, age_days, modified_time)
+    """
+    sessions_dir = get_sessions_dir(alita_dir)
+    
+    if not sessions_dir.exists():
+        return []
+    
+    sessions = []
+    now = datetime.now(timezone.utc)
+    
+    for session_path in sessions_dir.iterdir():
+        if not session_path.is_dir():
+            continue
+        
+        session_id = session_path.name
+        
+        # Get modification time (most recent file in session)
+        try:
+            mtime = max(
+                f.stat().st_mtime
+                for f in session_path.rglob('*')
+                if f.is_file()
+            )
+            modified = datetime.fromtimestamp(mtime, tz=timezone.utc)
+            age_days = (now - modified).total_seconds() / 86400
+            sessions.append((session_id, age_days, modified))
+        except (ValueError, OSError):
+            # No files or error accessing - use directory mtime
+            try:
+                mtime = session_path.stat().st_mtime
+                modified = datetime.fromtimestamp(mtime, tz=timezone.utc)
+                age_days = (now - modified).total_seconds() / 86400
+                sessions.append((session_id, age_days, modified))
+            except OSError:
+                continue
+    
+    # Sort by modification time (oldest first)
+    sessions.sort(key=lambda x: x[2])
+    
+    return sessions
+
+
+def purge_old_sessions(
+    max_age_days: int = 30,
+    max_sessions: int = 50,
+    alita_dir: str = '.alita',
+    dry_run: bool = False
+) -> Tuple[int, int]:
+    """
+    Purge old sessions based on age and count limits.
+    
+    Args:
+        max_age_days: Maximum age in days before a session is purged
+        max_sessions: Maximum number of sessions to keep
+        alita_dir: Base Alita directory
+        dry_run: If True, only report what would be deleted
+        
+    Returns:
+        Tuple of (sessions_deleted, bytes_freed)
+    """
+    sessions_dir = get_sessions_dir(alita_dir)
+    
+    if not sessions_dir.exists():
+        return 0, 0
+    
+    sessions = list_sessions_with_age(alita_dir)
+    
+    if not sessions:
+        return 0, 0
+    
+    to_delete = []
+    
+    # Mark sessions older than max_age_days for deletion
+    for session_id, age_days, modified in sessions:
+        if age_days > max_age_days:
+            to_delete.append(session_id)
+    
+    # If we still have too many sessions, delete oldest ones
+    remaining = [s for s in sessions if s[0] not in to_delete]
+    if len(remaining) > max_sessions:
+        # Sort remaining by age (oldest first) and mark excess for deletion
+        excess_count = len(remaining) - max_sessions
+        for session_id, age_days, modified in remaining[:excess_count]:
+            if session_id not in to_delete:
+                to_delete.append(session_id)
+    
+    # Delete marked sessions
+    deleted_count = 0
+    bytes_freed = 0
+    
+    for session_id in to_delete:
+        session_path = sessions_dir / session_id
+        
+        if not session_path.exists():
+            continue
+        
+        # Calculate size before deletion
+        try:
+            session_size = sum(
+                f.stat().st_size
+                for f in session_path.rglob('*')
+                if f.is_file()
+            )
+        except OSError:
+            session_size = 0
+        
+        if dry_run:
+            logger.info(f"Would delete session: {session_id} ({session_size} bytes)")
+        else:
+            try:
+                shutil.rmtree(session_path)
+                deleted_count += 1
+                bytes_freed += session_size
+                logger.debug(f"Deleted session: {session_id}")
+            except OSError as e:
+                logger.warning(f"Failed to delete session {session_id}: {e}")
+    
+    if deleted_count > 0:
+        logger.info(f"Purged {deleted_count} old sessions, freed {bytes_freed} bytes")
+    
+    return deleted_count, bytes_freed
+
+
+def get_session_disk_usage(alita_dir: str = '.alita') -> Tuple[int, int]:
+    """
+    Get disk usage statistics for sessions.
+    
+    Args:
+        alita_dir: Base Alita directory
+        
+    Returns:
+        Tuple of (session_count, total_bytes)
+    """
+    sessions_dir = get_sessions_dir(alita_dir)
+    
+    if not sessions_dir.exists():
+        return 0, 0
+    
+    session_count = 0
+    total_bytes = 0
+    
+    for session_path in sessions_dir.iterdir():
+        if not session_path.is_dir():
+            continue
+        
+        session_count += 1
+        
+        try:
+            session_size = sum(
+                f.stat().st_size
+                for f in session_path.rglob('*')
+                if f.is_file()
+            )
+            total_bytes += session_size
+        except OSError:
+            continue
+    
+    return session_count, total_bytes