daita-agents 0.1.0__py3-none-any.whl

daita/cli/core/status.py

@@ -0,0 +1,421 @@
+"""
+Simple status display for Daita CLI.
+Shows project and deployment status like git status.
+"""
+import json
+import yaml
+from pathlib import Path
+from datetime import datetime
+from ..utils import find_project_root
+
+
+async def show_project_status(environment=None, verbose=False):
+   """Show project status (like git status)."""
+   
+   # Find project root
+   project_root = find_project_root()
+   if not project_root:
+       raise ValueError("Not in a Daita project. Run 'daita init' first.")
+   
+   # Load project config
+   config = _load_project_config(project_root)
+   if not config:
+       print(" No daita-project.yaml found")
+       return
+   
+   project_name = config.get('name', 'Unknown')
+   version = config.get('version', '1.0.0')
+   
+   print(f" Project: {project_name} (v{version})")
+   print(f"Location: {project_root}")
+   print("")
+   
+   # Show components status
+   _show_components_status(project_root, config)
+   
+   # Check if user has DAITA_API_KEY for cloud status
+   import os
+   has_daita_key = bool(os.getenv('DAITA_API_KEY'))
+   
+   if has_daita_key:
+       # Show cloud deployment status
+       if environment:
+           await _show_cloud_environment_status(environment, verbose)
+       else:
+           await _show_cloud_deployments_status(verbose)
+   else:
+       # Show local deployment status only
+       print(" Cloud Deployments: Upgrade required")
+       print("   Get your API key at daita-tech.io")
+       print("   Local deployment history:")
+       _show_local_deployments_status(project_root, verbose)
+   
+   # Show any issues
+   _show_issues(project_root, config)
+
+def _show_components_status(project_root, config):
+   """Show status of agents and workflows."""
+   print(" Components:")
+   
+   # Check agents
+   agents = config.get('agents', [])
+   agents_dir = project_root / 'agents'
+   
+   # Fallback to filesystem scanning if config is empty
+   if not agents and agents_dir.exists():
+       agent_files = list(agents_dir.glob('*.py'))
+       agent_files = [f for f in agent_files if f.name != '__init__.py']
+       
+       if agent_files:
+           print(f"   Agents ({len(agent_files)}) [detected from filesystem]:")
+           for agent_file in agent_files:
+               agent_name = agent_file.stem
+               print(f"      {agent_name} (not in config)")
+       else:
+           print(f"   Agents: None")
+   elif agents:
+       print(f"   Agents ({len(agents)}):")
+       for agent in agents:
+           agent_file = agents_dir / f"{agent['name']}.py"
+           status = "" if agent_file.exists() else ""
+           display_name = agent.get('display_name', agent['name'])
+           print(f"     {status} {agent['name']} → '{display_name}'")
+   else:
+       print(f"   Agents: None")
+   
+   # Check workflows
+   workflows = config.get('workflows', [])
+   workflows_dir = project_root / 'workflows'
+   
+   # Fallback to filesystem scanning if config is empty
+   if not workflows and workflows_dir.exists():
+       workflow_files = list(workflows_dir.glob('*.py'))
+       workflow_files = [f for f in workflow_files if f.name != '__init__.py']
+       
+       if workflow_files:
+           print(f"   Workflows ({len(workflow_files)}) [detected from filesystem]:")
+           for workflow_file in workflow_files:
+               workflow_name = workflow_file.stem
+               print(f"      {workflow_name} (not in config)")
+       else:
+           print(f"   Workflows: None")
+   elif workflows:
+       print(f"   Workflows ({len(workflows)}):")
+       for workflow in workflows:
+           workflow_file = workflows_dir / f"{workflow['name']}.py"
+           status = "" if workflow_file.exists() else ""
+           display_name = workflow.get('display_name', workflow['name'])
+           print(f"     {status} {workflow['name']} → '{display_name}'")
+   else:
+       print(f"   Workflows: None")
+   
+   print("")
+
+def _show_environment_status(project_root, environment, verbose):
+   """Show status for specific environment."""
+   print(f" Environment: {environment}")
+   
+   # Load deployment history
+   deployments = _load_deployments(project_root)
+   env_deployments = [d for d in deployments if d['environment'] == environment]
+   
+   if env_deployments:
+       latest = env_deployments[-1]
+       deploy_time = latest['timestamp'][:19].replace('T', ' ')
+       
+       print(f"   Last deployed: {deploy_time}")
+       print(f"   Version: {latest.get('version', 'unknown')}")
+       
+       if verbose:
+           print(f"   Agents: {', '.join(latest.get('agents', []))}")
+           print(f"   Workflows: {', '.join(latest.get('workflows', []))}")
+   else:
+       print(f"   Never deployed to {environment}")
+   
+   print("")
+
+def _show_local_deployments_status(project_root, verbose):
+   """Show status of local deployment history."""
+   deployments = _load_deployments(project_root)
+   
+   if not deployments:
+       print("    No local deployment history")
+       print("")
+       return
+   
+   # Group by environment
+   env_deployments = {}
+   for deployment in deployments:
+       env = deployment['environment']
+       if env not in env_deployments:
+           env_deployments[env] = []
+       env_deployments[env].append(deployment)
+   
+   # Show each environment
+   for env, deps in env_deployments.items():
+       latest = deps[-1]
+       deploy_time = latest['timestamp'][:16].replace('T', ' ')
+       version = latest.get('version', '?')
+       
+       print(f"   {env}: v{version} ({deploy_time})")
+       
+       if verbose:
+           print(f"      {len(latest.get('agents', []))} agents")
+           print(f"      {len(latest.get('workflows', []))} workflows")
+   
+   print("")
+
+async def _show_cloud_deployments_status(verbose):
+   """Show status of cloud deployments via API."""
+   import os
+   import aiohttp
+
+   # Get current project name to filter deployments when in project directory
+   project_root = find_project_root()
+   config = _load_project_config(project_root) if project_root else None
+   current_project = config.get('name') if config else None
+
+   try:
+       api_key = os.getenv('DAITA_API_KEY')
+       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/api-key"
+           params = {}
+           if current_project:
+               params['project_name'] = current_project
+
+           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:
+                       if current_project:
+                           print(f" Cloud Deployments ({current_project}): None")
+                           print("   Run 'daita push staging' to deploy")
+                       else:
+                           print(" Cloud Deployments: None")
+                           print("   Run 'daita push staging' to deploy")
+                       print("")
+                       return
+
+                   # Update header to indicate scope
+                   if current_project:
+                       print(f" Cloud Deployments ({current_project}) ({len(deployments)}):")
+                   else:
+                       print(f" Cloud Deployments (Organization) ({len(deployments)}):")
+
+                   # Show most recent 5 deployments (API returns newest first)
+                   recent_deployments = deployments[:5]
+
+                   # Find most recent active deployment
+                   latest_active = None
+                   for deployment in deployments:
+                       if deployment.get('status') == 'active':
+                           latest_active = deployment
+                           break
+
+                   for deployment in recent_deployments:
+                       env = deployment.get('environment', 'unknown')
+                       version = deployment.get('version', '?')
+                       status = deployment.get('status', 'unknown')
+                       deployed_at = deployment.get('deployed_at', '')[:16].replace('T', ' ')
+
+                       # Check if this is the current active deployment
+                       is_current = (latest_active and
+                                   deployment.get('deployment_id') == latest_active.get('deployment_id'))
+                       current_text = " (current)" if is_current else ""
+
+                       status_icon = "●" if status == 'active' else "○"
+                       print(f"  {status_icon} {env}: v{version} ({deployed_at}){current_text}")
+                   
+                   print("")
+               else:
+                   print(" Cloud Deployments: Unable to fetch status")
+                   print("   Check your internet connection and API key")
+                   print("")
+   
+   except Exception:
+       print(" Cloud Deployments: Connection failed")
+       print("   Using local deployment history")
+       print("")
+
+async def _show_cloud_environment_status(environment, verbose):
+   """Show cloud status for specific environment."""
+   import os
+   import aiohttp
+
+   # Get current project name to filter deployments when in project directory
+   project_root = find_project_root()
+   config = _load_project_config(project_root) if project_root else None
+   current_project = config.get('name') if config else None
+
+   try:
+       api_key = os.getenv('DAITA_API_KEY')
+       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:
+           params = {'environment': environment}
+           if current_project:
+               params['project_name'] = current_project
+
+           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:
+                       if current_project:
+                           print(f" Environment: {environment} ({current_project})")
+                           print(f"    Never deployed to {environment}")
+                       else:
+                           print(f" Environment: {environment}")
+                           print(f"    Never deployed to {environment}")
+                       print("")
+                       return
+                   
+                   latest = deployments[-1]
+                   status = latest.get('status', 'unknown')
+                   version = latest.get('version', '?')
+                   deployed_at = latest.get('deployed_at', '')[:19].replace('T', ' ')
+                   
+                   status_icon = "" if status == 'deployed' else ""
+                   if current_project:
+                       print(f" Environment: {environment} ({current_project})")
+                   else:
+                       print(f" Environment: {environment}")
+                   print(f"  {status_icon} Status: {status}")
+                   print(f"   Last deployed: {deployed_at}")
+                   print(f"   Version: {version}")
+                   
+                   if verbose and 'functions' in latest:
+                       functions = latest['functions']
+                       print(f"   Functions: {len(functions)}")
+                       for func in functions:
+                           print(f"     • {func.get('name', 'unknown')}")
+                   
+                   print("")
+               else:
+                   print(f" Environment: {environment}")
+                   print("   Unable to fetch cloud status")
+                   print("")
+   
+   except Exception:
+       print(f" Environment: {environment}")
+       print("   Connection failed - using local history")
+       print("")
+
+def _show_issues(project_root, config):
+   """Show any issues with the project."""
+   issues = []
+   
+   # Check for missing files
+   required_files = ['daita-project.yaml', 'requirements.txt']
+   for file_name in required_files:
+       if not (project_root / file_name).exists():
+           issues.append(f"Missing {file_name}")
+   
+   # Check for missing agent files
+   agents = config.get('agents', [])
+   for agent in agents:
+       agent_file = project_root / 'agents' / f"{agent['name']}.py"
+       if not agent_file.exists():
+           issues.append(f"Missing agent file: {agent['name']}.py")
+   
+   # Check for missing workflow files
+   workflows = config.get('workflows', [])
+   for workflow in workflows:
+       workflow_file = project_root / 'workflows' / f"{workflow['name']}.py"
+       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.)")
+   
+   # Show issues
+   if issues:
+       print("  Issues:")
+       for issue in issues:
+           print(f"    {issue}")
+       print("")
+   else:
+       print(" No issues found")
+       print("")
+   
+   # Show helpful commands based on API key status
+   import os
+   has_daita_key = bool(os.getenv('DAITA_API_KEY'))
+   
+   print(" Quick commands:")
+   print("   daita create agent my_agent    # Create new agent (free)")
+   print("   daita test                     # Test all components (free)")
+   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")
+   else:
+       print("   ")
+       print("    Ready for cloud deployment?")
+       print("   Get your API key at daita-tech.io")
+
+def _load_deployments(project_root):
+   """Load deployment history."""
+   deployments_file = project_root / '.daita' / 'deployments.json'
+   
+   if not deployments_file.exists():
+       return []
+   
+   try:
+       with open(deployments_file, 'r') as f:
+           return json.load(f)
+   except:
+       return []
+
+def _load_project_config(project_root):
+   """Load project configuration."""
+   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:
+       return None
+
+def _has_api_key():
+   """Check if API key is configured."""
+   import os
+   return bool(
+       os.getenv('OPENAI_API_KEY') or 
+       os.getenv('ANTHROPIC_API_KEY') or
+       os.getenv('GEMINI_API_KEY')
+   )
+
+# Alias for backward compatibility
+show_status = show_project_status
+

daita/cli/core/test.py

@@ -0,0 +1,239 @@
+"""
+Simple testing for Daita CLI.
+Just runs agents and workflows locally.
+"""
+import asyncio
+import json
+import sys
+from pathlib import Path
+import importlib.util
+from ..utils import find_project_root
+
+async def run_tests(target=None, data_file=None, watch=False, verbose=False):
+   """Run tests for agents or workflows."""
+   
+   # Find project root
+   project_root = find_project_root()
+   if not project_root:
+       raise ValueError("Not in a Daita project. Run 'daita init' first.")
+   
+   # Load test data
+   test_data = _load_test_data(project_root, data_file)
+   
+   if target:
+       # Test specific agent or workflow
+       await _test_single(project_root, target, test_data, verbose)
+   else:
+       # Test everything
+       await _test_all(project_root, test_data, verbose)
+   
+   if watch:
+       print(f"\n  Watching for changes... (Press Ctrl+C to stop)")
+       try:
+           while True:
+               await asyncio.sleep(1)
+       except KeyboardInterrupt:
+           print(f"\n Stopped watching")
+
+async def _test_single(project_root, target, test_data, verbose):
+   """Test a single agent or workflow."""
+   print(f" Testing: {target}")
+   
+   # Try to find and load the target
+   agent_file = project_root / 'agents' / f'{target}.py'
+   workflow_file = project_root / 'workflows' / f'{target}.py'
+   
+   if agent_file.exists():
+       await _test_agent(agent_file, target, test_data, verbose)
+   elif workflow_file.exists():
+       await _test_workflow(workflow_file, target, test_data, verbose)
+   else:
+       print(f" Not found: {target}")
+
+async def _test_all(project_root, test_data, verbose):
+   """Test all agents and workflows."""
+   agents = _list_python_files(project_root / 'agents')
+   workflows = _list_python_files(project_root / 'workflows')
+   
+   print(f" Testing {len(agents)} agents and {len(workflows)} workflows")
+   
+   # Test agents
+   for agent in agents:
+       agent_file = project_root / 'agents' / f'{agent}.py'
+       await _test_agent(agent_file, agent, test_data, verbose)
+   
+   # Test workflows
+   for workflow in workflows:
+       workflow_file = project_root / 'workflows' / f'{workflow}.py'
+       await _test_workflow(workflow_file, workflow, test_data, verbose)
+
+async def _test_agent(agent_file, name, test_data, verbose):
+   """Test a single agent."""
+   try:
+       # Load the agent factory function
+       try:
+           agent_factory = _load_python_file(agent_file, 'create_agent')
+       except Exception as e:
+           print(f" {name}: Failed to load agent - {str(e)}")
+           return
+       
+       # Create agent instance
+       try:
+           agent_instance = agent_factory()
+       except Exception as e:
+           print(f" {name}: Failed to create agent instance - {str(e)}")
+           if verbose:
+               import traceback
+               traceback.print_exc()
+           return
+       
+       # Test basic processing
+       try:
+           result = await agent_instance.process("process_data", test_data)
+           
+           # Validate result format
+           if not isinstance(result, dict):
+               print(f"  {name}: Warning - agent returned {type(result).__name__} instead of dict")
+           
+           print(f" {name}: OK")
+           if verbose:
+               print(f"   Status: {result.get('status', 'unknown')}")
+               print(f"   Result type: {type(result).__name__}")
+               
+       except Exception as e:
+           print(f" {name}: Processing failed - {str(e)}")
+           if verbose:
+               import traceback
+               traceback.print_exc()
+           
+   except Exception as e:
+       print(f" {name}: Unexpected error - {str(e)}")
+       if verbose:
+           import traceback
+           traceback.print_exc()
+
+async def _test_workflow(workflow_file, name, test_data, verbose):
+   """Test a single workflow."""
+   try:
+       # Load the workflow factory function
+       try:
+           workflow_factory = _load_python_file(workflow_file, 'create_workflow')
+       except Exception as e:
+           print(f" {name}: Failed to load workflow - {str(e)}")
+           return
+       
+       # Create workflow instance
+       try:
+           workflow_instance = workflow_factory()
+       except Exception as e:
+           print(f" {name}: Failed to create workflow instance - {str(e)}")
+           if verbose:
+               import traceback
+               traceback.print_exc()
+           return
+       
+       # Test workflow run
+       try:
+           result = await workflow_instance.run(test_data)
+           
+           # Validate result format
+           if result is not None and not isinstance(result, dict):
+               print(f"  {name}: Warning - workflow returned {type(result).__name__} instead of dict")
+           
+           print(f" {name}: OK")
+           if verbose:
+               print(f"   Status: {result.get('status', 'unknown') if result else 'completed'}")
+               print(f"   Result type: {type(result).__name__ if result else 'None'}")
+               
+       except Exception as e:
+           print(f" {name}: Workflow run failed - {str(e)}")
+           if verbose:
+               import traceback
+               traceback.print_exc()
+           
+   except Exception as e:
+       print(f" {name}: Unexpected error - {str(e)}")
+       if verbose:
+           import traceback
+           traceback.print_exc()
+
+def _load_python_file(file_path, factory_function):
+   """Load a Python file and get the factory function."""
+   try:
+       # Add project root to path
+       project_root = file_path.parent.parent
+       if str(project_root) not in sys.path:
+           sys.path.insert(0, str(project_root))
+       
+       # Check if file exists and is readable
+       if not file_path.exists():
+           raise FileNotFoundError(f"File not found: {file_path}")
+       
+       if not file_path.is_file():
+           raise ValueError(f"Path is not a file: {file_path}")
+       
+       # Load module with better error handling
+       spec = importlib.util.spec_from_file_location("module", file_path)
+       if spec is None:
+           raise ImportError(f"Could not create module spec for {file_path}")
+       
+       module = importlib.util.module_from_spec(spec)
+       if module is None:
+           raise ImportError(f"Could not create module from spec for {file_path}")
+       
+       # Execute module with error handling
+       try:
+           spec.loader.exec_module(module)
+       except Exception as e:
+           raise ImportError(f"Failed to execute module {file_path.name}: {str(e)}")
+       
+       # Get factory function
+       if hasattr(module, factory_function):
+           return getattr(module, factory_function)
+       else:
+           # List available functions for better error message
+           available_functions = [name for name in dir(module) if callable(getattr(module, name)) and not name.startswith('_')]
+           raise ValueError(
+               f"No {factory_function}() function found in {file_path.name}. "
+               f"Available functions: {available_functions}"
+           )
+   
+   except (ImportError, ValueError, FileNotFoundError) as e:
+       # Re-raise known errors
+       raise
+   except Exception as e:
+       # Catch any other unexpected errors
+       raise RuntimeError(f"Unexpected error loading {file_path.name}: {str(e)}")
+
+def _load_test_data(project_root, data_file):
+   """Load test data from file or use default."""
+   if data_file:
+       data_path = Path(data_file)
+       if not data_path.is_absolute():
+           data_path = project_root / data_path
+       
+       if data_path.exists():
+           if data_path.suffix == '.json':
+               with open(data_path, 'r') as f:
+                   return json.load(f)
+           else:
+               with open(data_path, 'r') as f:
+                   return f.read()
+   
+   # Use default test data
+   return {
+       "test": True,
+       "message": "Default test data"
+   }
+
+def _list_python_files(directory):
+   """List Python files in a directory (excluding __init__.py)."""
+   if not directory.exists():
+       return []
+   
+   files = []
+   for file in directory.glob('*.py'):
+       if file.name != '__init__.py':
+           files.append(file.stem)
+   return files
+