daita-agents 0.2.0__py3-none-any.whl

daita/cli/core/deployments.py

@@ -0,0 +1,309 @@
+"""
+Deployment management commands for Daita CLI.
+
+Provides commands to list, download, and manage deployments.
+"""
+import os
+import json
+import asyncio
+from pathlib import Path
+from datetime import datetime
+from typing import Optional
+from ..utils import find_project_root
+
+async def list_deployments(project_name: Optional[str] = None, environment: Optional[str] = None, limit: int = 10):
+    """List deployment history from managed cloud API."""
+    import aiohttp
+
+    try:
+        # Get API key
+        api_key = os.getenv('DAITA_API_KEY')
+        if not api_key:
+            print(" No DAITA_API_KEY found")
+            print("   Get your API key at daita-tech.io")
+            print("   Then: export DAITA_API_KEY='your-key-here'")
+            return
+
+        # If no project specified, try to get from current directory
+        if not project_name:
+            project_root = find_project_root()
+            if project_root:
+                config = _load_project_config(project_root)
+                if config:
+                    project_name = config.get('name', 'unknown')
+
+        # Get API endpoint
+        api_endpoint = os.getenv('DAITA_API_ENDPOINT', 'https://ondk4sdyv0.execute-api.us-east-1.amazonaws.com')
+
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "User-Agent": "Daita-CLI/1.0.0"
+        }
+
+        # Build query parameters
+        params = {}
+        if project_name:
+            params['project_name'] = project_name
+        if environment:
+            params['environment'] = environment
+        if limit:
+            params['limit'] = limit
+
+        print(f" Deployment History{' for ' + repr(project_name) if project_name else ''}")
+        if environment:
+            print(f"   Environment: {environment}")
+        print()
+
+        # Fetch deployment history from API
+        async with aiohttp.ClientSession() as session:
+            url = f"{api_endpoint}/api/v1/deployments/api-key"
+
+            async with session.get(url, headers=headers, params=params, timeout=10) as response:
+                if response.status == 200:
+                    data = await response.json()
+
+                    # Handle paginated response from API
+                    if isinstance(data, dict) and 'deployments' in data:
+                        deployments = data['deployments']
+                    else:
+                        deployments = data if isinstance(data, list) else []
+
+                    if not deployments:
+                        print("   No deployments found.")
+                        return
+
+                    # Display deployments
+                    for i, deployment in enumerate(deployments[:limit], 1):
+                        status_emoji = "●" if deployment.get('status') == 'active' else "○"
+                        deployed_at = deployment.get('deployed_at', '')
+
+                        # Parse deployment timestamp
+                        try:
+                            deployed_date = datetime.fromisoformat(deployed_at.replace('Z', '+00:00'))
+                            deployed_str = deployed_date.strftime('%Y-%m-%d %H:%M:%S UTC')
+                        except:
+                            deployed_str = deployed_at
+
+                        deployment_id = deployment.get('deployment_id', 'unknown')
+
+                        print(f"{i:2}. {status_emoji} {deployment_id[:36]}")
+                        print(f"      Environment: {deployment.get('environment', 'unknown')}")
+                        print(f"      Version: {deployment.get('version', '1.0.0')}")
+                        print(f"      Deployed: {deployed_str}")
+
+                        # Show package size if available
+                        if 'package_size_bytes' in deployment:
+                            package_size_mb = deployment['package_size_bytes'] / 1024 / 1024
+                            print(f"      Package: {package_size_mb:.1f}MB")
+
+                        # Show agents from deployment info
+                        deployment_info = deployment.get('deployment_info', {})
+                        if deployment_info and 'functions' in deployment_info:
+                            agent_names = [f.get('agent_name', 'Unknown') for f in deployment_info['functions']]
+                            if agent_names:
+                                print(f"      Agents: {', '.join(agent_names)}")
+
+                        print()
+
+                    # Show total count if there are more
+                    total_count = len(deployments)
+                    if total_count > limit:
+                        print(f"   Showing {limit} of {total_count} deployments")
+                        print(f"   Use --limit {total_count} to see all deployments")
+
+                elif response.status == 401:
+                    print(" Authentication failed")
+                    print("   Check your DAITA_API_KEY")
+                else:
+                    error_text = await response.text()
+                    print(f" Failed to fetch deployments (HTTP {response.status})")
+                    print(f"   {error_text}")
+
+    except aiohttp.ClientConnectorError:
+        print(" Cannot connect to deployment API")
+        print("   Check your internet connection")
+    except Exception as e:
+        print(f" Failed to list deployments: {e}")
+
+async def download_deployment(deployment_id: str, output_path: Optional[str] = None):
+    """Download a deployment package."""
+    try:
+        from ...cloud.lambda_deploy import LambdaDeployer
+        
+        # Get AWS region
+        aws_region = os.getenv('AWS_REGION', 'us-east-1')
+        deployer = LambdaDeployer(aws_region)
+        
+        # Determine output path
+        if not output_path:
+            output_path = f"{deployment_id}.zip"
+        
+        output_file = Path(output_path)
+        
+        print(f" Downloading deployment: {deployment_id}")
+        print(f"   Output: {output_file.absolute()}")
+        
+        # Download deployment
+        success = await deployer.download_deployment(deployment_id, output_file)
+        
+        if success:
+            file_size = output_file.stat().st_size
+            print(f" Downloaded successfully ({file_size / 1024 / 1024:.1f}MB)")
+        else:
+            print(f" Download failed")
+    
+    except Exception as e:
+        print(f" Failed to download deployment: {e}")
+
+async def show_deployment_details(deployment_id: str):
+    """Show detailed information about a deployment."""
+    try:
+        from ...cloud.lambda_deploy import LambdaDeployer
+        
+        # Get AWS region
+        aws_region = os.getenv('AWS_REGION', 'us-east-1')
+        deployer = LambdaDeployer(aws_region)
+        
+        print(f" Deployment Details: {deployment_id}")
+        print()
+        
+        # Get all deployments and find the target
+        all_deployments = await deployer.get_deployment_history('all', limit=100)
+        target_deployment = None
+        
+        for deployment in all_deployments:
+            if deployment['deployment_id'] == deployment_id:
+                target_deployment = deployment
+                break
+        
+        if not target_deployment:
+            print(f" Deployment {deployment_id} not found")
+            return
+        
+        # Display detailed information
+        deployed_date = datetime.fromisoformat(target_deployment['deployed_at'].replace('Z', '+00:00'))
+        
+        print(f"Project: {target_deployment['project_name']}")
+        print(f"Environment: {target_deployment['environment']}")
+        print(f"Version: {target_deployment.get('version', '1.0.0')}")
+        print(f"Deployed At: {deployed_date.strftime('%Y-%m-%d %H:%M:%S UTC')}")
+        print(f"Package Size: {target_deployment.get('package_size_bytes', 0) / 1024 / 1024:.1f}MB")
+        print(f"Package Hash: {target_deployment.get('package_hash', 'N/A')}")
+        
+        if target_deployment.get('s3_bucket'):
+            print(f"S3 Location: s3://{target_deployment['s3_bucket']}/{target_deployment['s3_key']}")
+        
+        print()
+        
+        # Show agents
+        agents = target_deployment.get('agents', [])
+        if agents:
+            print("Agents:")
+            for agent in agents:
+                print(f"   {agent.get('name', 'Unknown')}")
+                print(f"      Type: {agent.get('type', 'substrate')}")
+                print(f"      Enabled: {agent.get('enabled', True)}")
+                if agent.get('file'):
+                    print(f"      File: {agent['file']}")
+                print()
+        
+        # Show workflows
+        workflows = target_deployment.get('workflows', [])
+        if workflows:
+            print("Workflows:")
+            for workflow in workflows:
+                print(f"   {workflow.get('name', 'Unknown')}")
+                print(f"      Type: {workflow.get('type', 'basic')}")
+                print(f"      Enabled: {workflow.get('enabled', True)}")
+                if workflow.get('file'):
+                    print(f"      File: {workflow['file']}")
+                print()
+    
+    except Exception as e:
+        print(f" Failed to get deployment details: {e}")
+
+async def rollback_deployment(deployment_id: str, environment: str = 'production'):
+    """Rollback to a previous deployment."""
+    try:
+        from ...cloud.lambda_deploy import LambdaDeployer
+        
+        # Get AWS region
+        aws_region = os.getenv('AWS_REGION', 'us-east-1')
+        deployer = LambdaDeployer(aws_region)
+        
+        print(f" Rolling back to deployment: {deployment_id}")
+        print(f"   Target environment: {environment}")
+        
+        # Confirm rollback
+        if environment == 'production':
+            confirm = input("  Rollback PRODUCTION environment? Type 'yes' to confirm: ")
+            if confirm != 'yes':
+                print(" Rollback cancelled")
+                return
+        
+        # Perform rollback
+        result = await deployer.rollback_deployment(deployment_id, environment)
+        
+        if result['status'] == 'success':
+            print(f" Rollback initiated")
+            print(f"   New deployment ID: {result['rollback_deployment_id']}")
+            print(f"   Original deployment: {result['original_deployment_id']}")
+            print(f"   {result['message']}")
+        else:
+            print(f" Rollback failed: {result['error']}")
+    
+    except Exception as e:
+        print(f" Failed to rollback deployment: {e}")
+
+async def delete_deployment(deployment_id: str, force: bool = False):
+    """Delete a deployment and its Lambda functions."""
+    try:
+        from ...cloud.lambda_deploy import LambdaDeployer
+        
+        # Get AWS region
+        aws_region = os.getenv('AWS_REGION', 'us-east-1')
+        deployer = LambdaDeployer(aws_region)
+        
+        print(f"  Deleting deployment: {deployment_id}")
+        
+        # Confirm deletion
+        if not force:
+            confirm = input("  Delete deployment and all Lambda functions? Type 'yes' to confirm: ")
+            if confirm != 'yes':
+                print(" Deletion cancelled")
+                return
+        
+        # Delete deployment
+        result = await deployer.delete_deployment(deployment_id)
+        
+        if result['deleted_functions']:
+            print(f" Deleted {len(result['deleted_functions'])} Lambda functions:")
+            for func_name in result['deleted_functions']:
+                print(f"    {func_name}")
+        
+        if result['errors']:
+            print(f"  {len(result['errors'])} errors occurred:")
+            for error in result['errors']:
+                print(f"    {error}")
+        
+        print(f"   Note: S3 packages are retained for audit purposes")
+    
+    except Exception as e:
+        print(f" Failed to delete deployment: {e}")
+
+# Helper functions
+
+
+def _load_project_config(project_root: Path):
+    """Load project configuration from daita-project.yaml."""
+    import yaml
+    
+    config_file = project_root / 'daita-project.yaml'
+    if not config_file.exists():
+        return None
+    
+    try:
+        with open(config_file, 'r') as f:
+            return yaml.safe_load(f)
+    except Exception:
+        return None

daita/cli/core/import_detector.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+"""
+Import Detection for Daita Lambda Layer Optimization
+
+Analyzes user code to detect package imports and determine which Lambda layers
+are needed for deployment. This enables smart layer selection to minimize
+package sizes while ensuring all dependencies are available.
+"""
+
+import ast
+import os
+from pathlib import Path
+from typing import Set, Dict, List, Optional
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ImportDetector:
+    """Detects package imports in Python code to optimize Lambda layer selection."""
+    
+    def __init__(self):
+        # Define packages available in each layer
+        self.layer_packages = {
+            'common_dependencies': {
+                'requests',
+                'dateutil', 'python_dateutil',  # python-dateutil can be imported as either
+                'PIL', 'pillow',  # Pillow can be imported as PIL
+                'tqdm',
+                'joblib'
+            },
+            'core_dependencies': {
+                'pydantic', 'pydantic_core',
+                'httpx',
+                'aiofiles',
+                'boto3', 'botocore'
+            }
+        }
+        
+        # Mapping of import names to actual package names
+        self.import_mappings = {
+            'PIL': 'pillow',
+            'dateutil': 'python_dateutil',
+            'cv2': 'opencv_python',
+            'sklearn': 'scikit_learn',
+            'skimage': 'scikit_image'
+        }
+    
+    def analyze_file(self, file_path: Path) -> Set[str]:
+        """Analyze a single Python file and return set of imported packages."""
+        imports = set()
+        
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            tree = ast.parse(content)
+            
+            for node in ast.walk(tree):
+                if isinstance(node, ast.Import):
+                    for alias in node.names:
+                        package_name = alias.name.split('.')[0]
+                        imports.add(package_name)
+                
+                elif isinstance(node, ast.ImportFrom):
+                    if node.module:
+                        package_name = node.module.split('.')[0]
+                        imports.add(package_name)
+            
+        except Exception as e:
+            logger.warning(f"Could not parse {file_path}: {e}")
+        
+        return imports
+    
+    def analyze_directory(self, directory: Path, exclude_patterns: Optional[List[str]] = None) -> Set[str]:
+        """Analyze all Python files in a directory and return all imported packages."""
+        if exclude_patterns is None:
+            exclude_patterns = ['__pycache__', '.git', 'node_modules', '.venv', 'venv']
+        
+        all_imports = set()
+        
+        for root, dirs, files in os.walk(directory):
+            # Filter out excluded directories
+            dirs[:] = [d for d in dirs if not any(pattern in d for pattern in exclude_patterns)]
+            
+            for file in files:
+                if file.endswith('.py'):
+                    file_path = Path(root) / file
+                    file_imports = self.analyze_file(file_path)
+                    all_imports.update(file_imports)
+        
+        return all_imports
+    
+    def normalize_package_name(self, import_name: str) -> str:
+        """Normalize import name to actual package name using mappings."""
+        return self.import_mappings.get(import_name, import_name)
+    
+    def detect_required_layers(self, imports: Set[str]) -> Dict[str, List[str]]:
+        """Determine which layers are needed based on detected imports."""
+        required_layers = {}
+        
+        # Normalize import names
+        normalized_imports = {self.normalize_package_name(imp) for imp in imports}
+        
+        for layer_name, layer_packages in self.layer_packages.items():
+            matching_packages = []
+            
+            for package in layer_packages:
+                if package in normalized_imports or package in imports:
+                    matching_packages.append(package)
+            
+            if matching_packages:
+                required_layers[layer_name] = matching_packages
+        
+        return required_layers
+    
+    def analyze_project(self, project_path: Path) -> Dict[str, any]:
+        """Analyze an entire project and return comprehensive import analysis."""
+        logger.info(f" Analyzing imports in project: {project_path}")
+        
+        # Detect all imports
+        all_imports = self.analyze_directory(project_path)
+        
+        # Determine required layers
+        required_layers = self.detect_required_layers(all_imports)
+        
+        # Calculate optimization potential
+        layer_packages_found = set()
+        for packages in required_layers.values():
+            layer_packages_found.update(packages)
+        
+        analysis = {
+            'total_imports': len(all_imports),
+            'all_imports': sorted(list(all_imports)),
+            'required_layers': required_layers,
+            'layer_packages_detected': sorted(list(layer_packages_found)),
+            'optimization_potential': len(layer_packages_found) > 0
+        }
+        
+        logger.info(f" Analysis complete:")
+        logger.info(f"    Total imports detected: {analysis['total_imports']}")
+        logger.info(f"    Layer packages found: {len(layer_packages_found)}")
+        logger.info(f"    Layers needed: {list(required_layers.keys())}")
+        
+        return analysis
+    
+    def get_layer_arns_for_project(self, project_path: Path, layer_config_path: Path) -> List[str]:
+        """Get the specific layer ARNs needed for a project based on its imports."""
+        import json
+        
+        # Analyze project imports
+        analysis = self.analyze_project(project_path)
+        required_layers = analysis['required_layers']
+        
+        # Load layer configuration
+        if not layer_config_path.exists():
+            logger.warning(f"Layer config not found at {layer_config_path}")
+            return []
+        
+        with open(layer_config_path, 'r') as f:
+            layer_config = json.load(f)
+        
+        # Map layer types to ARNs
+        layer_arn_mapping = {
+            'common_dependencies': layer_config.get('ml_dependencies_layer_arn'),
+            'core_dependencies': layer_config.get('dependencies_layer_arn')
+        }
+        
+        # Get ARNs for required layers
+        required_arns = []
+        for layer_name in required_layers.keys():
+            if layer_name in layer_arn_mapping and layer_arn_mapping[layer_name]:
+                required_arns.append(layer_arn_mapping[layer_name])
+                logger.info(f" Including {layer_name} layer: {layer_arn_mapping[layer_name]}")
+        
+        # Always include framework layer
+        framework_arn = layer_config.get('framework_layer_arn')
+        if framework_arn:
+            required_arns.append(framework_arn)
+            logger.info(f" Including framework layer: {framework_arn}")
+        
+        return required_arns
+
+def main():
+    """CLI entry point for import detection."""
+    import sys
+    
+    if len(sys.argv) < 2:
+        print("Usage: python import_detector.py <project_path>")
+        sys.exit(1)
+    
+    project_path = Path(sys.argv[1])
+    if not project_path.exists():
+        print(f"Error: Project path {project_path} does not exist")
+        sys.exit(1)
+    
+    detector = ImportDetector()
+    analysis = detector.analyze_project(project_path)
+    
+    print("\n" + "="*60)
+    print(" IMPORT ANALYSIS RESULTS")
+    print("="*60)
+    print(f" Total imports: {analysis['total_imports']}")
+    print(f" Layer-optimizable packages: {len(analysis['layer_packages_detected'])}")
+    print(f" Optimization potential: {'Yes' if analysis['optimization_potential'] else 'No'}")
+    
+    if analysis['required_layers']:
+        print("\n Required layers:")
+        for layer, packages in analysis['required_layers'].items():
+            print(f"   {layer}: {', '.join(packages)}")
+    
+    print("\n All detected imports:")
+    for imp in analysis['all_imports']:
+        status = "" if imp in analysis['layer_packages_detected'] else ""
+        print(f"   {status} {imp}")
+    
+    print("="*60)
+
+if __name__ == "__main__":
+    main()