daita-agents 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

daita/cli/__init__.py

@@ -16,8 +16,7 @@ Example usage:
     daita test --watch
     
     # Deploy
-    daita push staging
-    daita push production --force
+    daita push
     
     # Monitor
     daita status
@@ -25,7 +24,7 @@ Example usage:
 """
 
 # CLI version
-__version__ = "0.1.1"
+__version__ = "0.1.2"
 
 # Import main CLI components
 from .main import cli, main

daita/cli/core/deployments.py

@@ -1,7 +1,7 @@
 """
 Deployment management commands for Daita CLI.
 
-Provides commands to list, download, and manage deployments.
+Provides commands to list and manage deployments.
 """
 import os
 import json
@@ -125,36 +125,6 @@ async def list_deployments(project_name: Optional[str] = None, environment: Opti
     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:
@@ -188,11 +158,6 @@ async def show_deployment_details(deployment_id: str):
         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
@@ -256,38 +221,54 @@ async def rollback_deployment(deployment_id: str, environment: str = 'production
         print(f" Failed to rollback deployment: {e}")
 
 async def delete_deployment(deployment_id: str, force: bool = False):
-    """Delete a deployment and its Lambda functions."""
+    """Delete a deployment via API."""
+    import aiohttp
+
     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}")
-        
+        # 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")
+            return
+
+        print(f" Deleting deployment: {deployment_id}")
+
         # Confirm deletion
         if not force:
-            confirm = input("  Delete deployment and all Lambda functions? Type 'yes' to confirm: ")
+            confirm = input("  Delete deployment? 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")
-    
+
+        # 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"
+        }
+
+        async with aiohttp.ClientSession() as session:
+            url = f"{api_endpoint}/api/v1/deployments/{deployment_id}"
+
+            async with session.delete(url, headers=headers, timeout=30) as response:
+                if response.status == 200:
+                    result = await response.json()
+                    print(f" {result.get('message', 'Deployment deleted successfully')}")
+                elif response.status == 404:
+                    print(" Deployment not found")
+                elif response.status == 401:
+                    print(" Authentication failed")
+                    print("   Check your DAITA_API_KEY")
+                else:
+                    error_text = await response.text()
+                    print(f" Deletion failed (HTTP {response.status})")
+                    print(f"   {error_text}")
+
+    except aiohttp.ClientConnectorError:
+        print(" Cannot connect to API")
+        print("   Check your internet connection")
     except Exception as e:
         print(f" Failed to delete deployment: {e}")
 

daita/cli/core/logs.py

@@ -48,13 +48,13 @@ async def show_deployment_logs(environment=None, limit=10, follow=False, verbose
                print(f" No deployments found ({current_project}, {environment})")
            else:
                print(f" No deployments found ({current_project})")
-           print("   Run 'daita push staging' to create your first deployment")
+           print("   Run 'daita push' to create your first deployment")
        else:
            print(" No deployments found")
            if environment:
                print(f"   No deployments found for environment: {environment}")
            else:
-               print("   Run 'daita push staging' to create your first deployment")
+               print("   Run 'daita push' to create your first deployment")
        return
 
    # Filter by environment if specified (additional client-side filtering)

daita/cli/core/run.py

@@ -234,16 +234,16 @@ async def _follow_execution(
 
 async def _poll_for_result(
     session: aiohttp.ClientSession,
-    api_base: str, 
+    api_base: str,
     headers: Dict[str, str],
     execution_id: str,
     verbose: bool
 ) -> bool:
     """Poll for execution result without showing progress (for non-follow mode)."""
-    
+
     max_polls = 360  # 3 minutes max wait (0.5s intervals)
     polls = 0
-    
+
     while polls < max_polls:
         try:
             # Check execution status
@@ -251,86 +251,128 @@ async def _poll_for_result(
                 f"{api_base}/api/v1/executions/{execution_id}",
                 headers=headers
             ) as response:
-                
+
                 if response.status != 200:
-                    click.echo("⚠️ Failed to get execution status", err=True)
+                    click.echo(" Failed to get execution status", err=True)
                     return False
-                
+
                 result = await response.json()
                 status = result['status']
-                
+
                 # Return result if complete
                 if status in ['completed', 'success']:  # Handle both status values
-                    click.echo("✅ Execution completed")
+                    click.echo("\n" + "=" * 60)
+                    click.echo(" EXECUTION COMPLETED")
+                    click.echo("=" * 60)
                     _display_result(result, verbose)
                     return True
                 elif status in ['failed', 'error']:  # Handle both status values
-                    click.echo("❌ Execution failed")
+                    click.echo("\n" + "=" * 60)
+                    click.echo(" EXECUTION FAILED")
+                    click.echo("=" * 60)
                     if result.get('error'):
-                        click.echo(f"   Error: {result['error']}")
+                        click.echo(f"\nError: {result['error']}")
                     return False
                 elif status == 'cancelled':
-                    click.echo("🚫 Execution cancelled")
+                    click.echo(" Execution cancelled")
                     return False
-                
+
                 # Continue polling
                 await asyncio.sleep(0.5)
                 polls += 1
-                
+
         except Exception as e:
-            click.echo(f"⚠️ Error polling execution: {e}", err=True)
+            click.echo(f" Error polling execution: {e}", err=True)
             return False
-    
+
     # Timeout reached
-    click.echo("⏰ Execution still running (timeout reached)")
-    click.echo(f"   Check status with: daita logs --execution-id {execution_id}")
-    click.echo(f"   Follow progress with: daita run {execution_id} --follow")
+    click.echo(" Execution still running (timeout reached)")
+    click.echo(f"   Check status with: daita execution-logs {execution_id}")
+    click.echo(f"   Follow progress with: daita execution-logs {execution_id} --follow")
     return False
 
 def _display_result(result: Dict[str, Any], verbose: bool):
     """Display execution results in a formatted way."""
-    
-    # Display basic info
+
+    # Display execution metadata
+    click.echo("\nExecution Metadata:")
+    click.echo("-" * 60)
+
     if result.get('duration_ms'):
         duration = float(result['duration_ms'])  # Convert string to number
         if duration < 1000:
-            click.echo(f"  Duration: {duration:.0f}ms")
+            click.echo(f"  Duration:    {duration:.0f}ms")
         elif duration < 60000:
-            click.echo(f"  Duration: {duration/1000:.1f}s")
+            click.echo(f"  Duration:    {duration/1000:.1f}s")
         else:
-            click.echo(f"  Duration: {duration/60000:.1f}m")
-    
+            click.echo(f"  Duration:    {duration/60000:.1f}m")
+
     if result.get('memory_used_mb'):
-        click.echo(f" Memory: {result['memory_used_mb']:.1f}MB")
-    
+        click.echo(f"  Memory:      {result['memory_used_mb']:.1f}MB")
+
     # Display result data
     if result.get('result'):
-        click.echo("\n Result:")
+        click.echo("\n" + "-" * 60)
+        click.echo("Result:")
+        click.echo("-" * 60)
+
         if verbose:
-            # Pretty print full result
-            click.echo(json.dumps(result['result'], indent=2))
+            # Pretty print full result with indentation
+            result_json = json.dumps(result['result'], indent=2)
+            for line in result_json.split('\n'):
+                click.echo(f"  {line}")
         else:
             # Display summary
             result_data = result['result']
+
             if isinstance(result_data, dict):
+                # Show key fields if present
                 if 'status' in result_data:
-                    click.echo(f"   Status: {result_data['status']}")
+                    click.echo(f"  Status:      {result_data['status']}")
                 if 'message' in result_data:
-                    click.echo(f"   Message: {result_data['message']}")
+                    # Word wrap long messages
+                    message = result_data['message']
+                    if len(message) > 70:
+                        click.echo(f"  Message:     {message[:70]}...")
+                    else:
+                        click.echo(f"  Message:     {message}")
+
+                # Show presence of complex data types
+                data_types = []
                 if 'insights' in result_data:
-                    click.echo("   Contains: insights data")
+                    data_types.append('insights')
                 if 'recommendations' in result_data:
-                    click.echo("   Contains: recommendations")
-                
-                # Show keys for complex objects
-                if len(result_data) > 3:
-                    keys = list(result_data.keys())[:5]
-                    if len(result_data) > 5:
-                        keys.append("...")
-                    click.echo(f"   Keys: {', '.join(keys)}")
+                    data_types.append('recommendations')
+                if 'data' in result_data:
+                    data_types.append('data')
+                if 'results' in result_data:
+                    data_types.append('results')
+
+                if data_types:
+                    click.echo(f"  Contains:    {', '.join(data_types)}")
+
+                # Show all keys for reference
+                all_keys = list(result_data.keys())
+                if len(all_keys) > 0:
+                    keys_display = ', '.join(all_keys[:8])
+                    if len(all_keys) > 8:
+                        keys_display += f" (+{len(all_keys) - 8} more)"
+                    click.echo(f"  Keys:        {keys_display}")
+
+                click.echo("\n  Tip: Use --verbose or -v flag to see full result")
+
+            elif isinstance(result_data, str):
+                # String result - show first part
+                if len(result_data) > 200:
+                    click.echo(f"  {result_data[:200]}...")
+                    click.echo(f"\n  (Result truncated - use -v for full output)")
+                else:
+                    click.echo(f"  {result_data}")
             else:
-                click.echo(f"   {result_data}")
-    
+                # Other types
+                click.echo(f"  {result_data}")
+
+    click.echo("=" * 60 + "\n")
 
 async def list_remote_executions(
     limit: int = 10,
@@ -371,8 +413,14 @@ async def list_remote_executions(
             ) as response:
                 
                 if response.status != 200:
-                    error_data = await response.json()
-                    click.echo(f" Failed to list executions: {error_data.get('detail', 'Unknown error')}", err=True)
+                    try:
+                        error_data = await response.json()
+                        error_msg = error_data.get('detail', 'Unknown error')
+                    except:
+                        error_msg = await response.text()
+                    click.echo(f" Failed to list executions: {error_msg}", err=True)
+                    if verbose:
+                        click.echo(f"   Status code: {response.status}", err=True)
                     return False
                 
                 executions = await response.json()
@@ -380,28 +428,33 @@ async def list_remote_executions(
                 if not executions:
                     click.echo(" No executions found")
                     return True
-                
-                # Display executions
-                click.echo(f" Recent executions ({len(executions)}):")
-                click.echo()
-                
+
+                # Display executions header
+                click.echo(f"\n Recent Executions ({len(executions)})")
+                click.echo(" " + "=" * 70)
+                click.echo(f" {'Status':<10} {'Agent/Workflow':<25} {'Time & Duration'}")
+                click.echo(" " + "-" * 70)
+
                 for execution in executions:
-                    # Status icon
-                    status_icon = {
-                        'completed': '',
-                        'failed': '',
-                        'running': '',
-                        'queued': '',
-                        'cancelled': ''
-                    }.get(execution['status'], '❓')
-                    
+                    # Map status to friendly text labels
+                    status_label = {
+                        'completed': 'success',
+                        'success': 'success',
+                        'failed': 'error',
+                        'error': 'error',
+                        'running': 'running',
+                        'queued': 'queued',
+                        'cancelled': 'cancelled',
+                        'started': 'running'
+                    }.get(execution['status'], execution['status'])
+
                     # Format time
                     created_at = execution['created_at']
                     if 'T' in created_at:
                         time_str = created_at.split('T')[1].split('.')[0]
                     else:
                         time_str = created_at
-                    
+
                     # Format duration
                     duration_str = "N/A"
                     if execution.get('duration_ms'):
@@ -412,19 +465,31 @@ async def list_remote_executions(
                             duration_str = f"{ms/1000:.1f}s"
                         else:
                             duration_str = f"{ms/60000:.1f}m"
-                    
-                    click.echo(f"{status_icon} {execution['target_name']} ({execution['target_type']})")
-                    click.echo(f"   {execution['execution_id'][:8]}... | {time_str} | {duration_str} | {execution['environment']}")
-                    
+
+                    # Format agent/workflow name with type
+                    target_info = f"{execution['target_name']} ({execution['target_type']})"
+
+                    # Format time and duration info
+                    time_duration = f"{time_str} ({duration_str})"
+
+                    # Display execution line
+                    click.echo(f" {status_label:<10} {target_info:<25} {time_duration}")
+
+                    # Show full execution ID on next line (indented)
+                    click.echo(f" {'':>10} ID: {execution['execution_id']}")
+
                     if verbose and execution.get('error'):
-                        click.echo(f"   Error: {execution['error']}")
-                    
-                    click.echo()
+                        click.echo(f" {'':>10} Error: {execution['error']}")
+
+                    click.echo()  # Blank line between executions
                 
                 return True
-                
+
     except Exception as e:
-        click.echo(f" Error: {e}", err=True)
+        click.echo(f" Failed to list executions: {e}", err=True)
+        if verbose:
+            import traceback
+            click.echo(traceback.format_exc(), err=True)
         return False
 
 async def get_execution_logs(

daita/cli/core/status.py

@@ -203,10 +203,10 @@ async def _show_cloud_deployments_status(verbose):
                    if not deployments:
                        if current_project:
                            print(f" Cloud Deployments ({current_project}): None")
-                           print("   Run 'daita push staging' to deploy")
+                           print("   Run 'daita push' to deploy")
                        else:
                            print(" Cloud Deployments: None")
-                           print("   Run 'daita push staging' to deploy")
+                           print("   Run 'daita push' to deploy")
                        print("")
                        return
 
@@ -351,9 +351,15 @@ def _show_issues(project_root, config):
        if not workflow_file.exists():
            issues.append(f"Missing workflow file: {workflow['name']}.py")
    
-   # Check for LLM API key
-   if not _has_api_key():
-       issues.append("No LLM API key found (set OPENAI_API_KEY, ANTHROPIC_API_KEY, etc.)")
+   # Check for LLM API key (check both local env and project .env for deployments)
+   has_local_key = _has_api_key()
+   has_project_env_key = _has_api_key_in_project_env(project_root)
+
+   if not has_local_key and not has_project_env_key:
+       issues.append("No LLM API key found (set OPENAI_API_KEY, ANTHROPIC_API_KEY, etc. in .env or environment)")
+   elif not has_local_key:
+       # Has key in project .env (for deployments) but not in local env (for local testing)
+       issues.append("No LLM API key in local environment (project .env has keys for deployment)")
    
    # Show issues
    if issues:
@@ -375,8 +381,8 @@ def _show_issues(project_root, config):
    print("   daita test --watch             # Development mode (free)")
    
    if has_daita_key:
-       print("   daita push staging             # Deploy to cloud")
-       print("   daita logs staging             # View cloud logs")
+       print("   daita push             # Deploy to cloud")
+       print("   daita logs             # View cloud logs")
    else:
        print("   ")
        print("    Ready for cloud deployment?")
@@ -408,14 +414,52 @@ def _load_project_config(project_root):
        return None
 
 def _has_api_key():
-   """Check if API key is configured."""
+   """Check if API key is configured in local environment."""
    import os
    return bool(
-       os.getenv('OPENAI_API_KEY') or 
+       os.getenv('OPENAI_API_KEY') or
        os.getenv('ANTHROPIC_API_KEY') or
-       os.getenv('GEMINI_API_KEY')
+       os.getenv('GEMINI_API_KEY') or
+       os.getenv('GROK_API_KEY')
    )
 
+def _has_api_key_in_project_env(project_root):
+   """Check if API key is configured in project's .env file (for deployments)."""
+   env_file = project_root / '.env'
+   if not env_file.exists():
+       return False
+
+   try:
+       with open(env_file, 'r') as f:
+           env_content = f.read()
+
+       # Check for LLM API key patterns in .env file
+       llm_key_patterns = [
+           'OPENAI_API_KEY=',
+           'ANTHROPIC_API_KEY=',
+           'GEMINI_API_KEY=',
+           'GROK_API_KEY='
+       ]
+
+       for pattern in llm_key_patterns:
+           for line in env_content.splitlines():
+               # Skip comments and empty lines
+               line = line.strip()
+               if line.startswith('#') or not line:
+                   continue
+
+               # Check if line has the pattern and a non-empty value
+               if line.startswith(pattern):
+                   value = line.split('=', 1)[1].strip()
+                   # Remove quotes if present
+                   value = value.strip('"').strip("'")
+                   if value and value != 'your-key-here' and value != 'sk-...':
+                       return True
+
+       return False
+   except Exception:
+       return False
+
 # Alias for backward compatibility
 show_status = show_project_status