daita-agents 0.1.0__py3-none-any.whl

daita/cli/core/init.py

@@ -0,0 +1,382 @@
+"""
+Simple project initialization for Daita CLI.
+Creates minimal, universal project template like create-react-app.
+"""
+import os
+import yaml
+from pathlib import Path
+from datetime import datetime
+from ..utils import find_project_root
+
+async def initialize_project(project_name=None, project_type='basic', template=None, force=False, verbose=False):
+    """Initialize a new Daita project with minimal template."""
+    
+    # Get project name
+    if not project_name:
+        project_name = input("Project name: ").strip()
+        if not project_name:
+            project_name = Path.cwd().name
+    
+    # Determine project directory
+    project_dir = Path.cwd() / project_name
+    
+    # Check if directory exists
+    if project_dir.exists() and not force:
+        if any(project_dir.iterdir()):  # Directory not empty
+            confirm = input(f"Directory '{project_name}' exists and is not empty. Continue? (y/N): ")
+            if confirm.lower() != 'y':
+                print(" Initialization cancelled")
+                return
+    
+    # Create project directory
+    project_dir.mkdir(exist_ok=True)
+    
+    print(f" Creating Daita project: {project_name}")
+    print(f" Location: {project_dir}")
+    
+    # Create minimal project structure
+    _create_project_structure(project_dir, verbose)
+    _create_project_config(project_dir, project_name, verbose)
+    _create_starter_files(project_dir, project_name, verbose)
+    _create_supporting_files(project_dir, project_name, verbose)
+    
+    # Import freemium utilities
+    try:
+        from ..utils import get_freemium_success_message
+        print("")
+        print(get_freemium_success_message(project_name))
+        print("")
+        print(" Development setup:")
+        print(f"   export OPENAI_API_KEY=your_key_here    # Configure LLM")
+        print(f"   pip install -r requirements.txt       # Install dependencies")
+        print(f"   python agents/my_agent.py              # Test example agent")
+    except ImportError:
+        # Fallback to original message if utils not available
+        print(f"")
+        print(f"Project created successfully")
+        print(f"")
+        print(f"Get started:")
+        print(f"   cd {project_name}")
+        print(f"   export OPENAI_API_KEY=your_key_here")
+        print(f"   pip install -r requirements.txt")
+        print(f"   python agents/my_agent.py          # Test the example agent")
+        print(f"   daita create agent new_agent       # Create a new agent")
+        print(f"   daita test                         # Test all components")
+        print(f"   daita test --watch                 # Watch for changes while developing")
+
+def _create_project_structure(project_dir, verbose):
+    """Create minimal directory structure."""
+    directories = [
+        '.daita',
+        'agents',
+        'workflows', 
+        'data',
+        'tests'
+    ]
+    
+    for dir_name in directories:
+        dir_path = project_dir / dir_name
+        dir_path.mkdir(exist_ok=True)
+        
+        # Create __init__.py for Python packages
+        if dir_name in ['agents', 'workflows', 'tests']:
+            init_file = dir_path / '__init__.py'
+            init_file.write_text('"""Daita project components."""\n')
+        
+        if verbose:
+            print(f"    Created: {dir_name}/")
+
+def _create_project_config(project_dir, project_name, verbose):
+    """Create minimal daita-project.yaml configuration."""
+    
+    config = {
+        'name': project_name,
+        'version': '1.0.0',
+        'description': f'A Daita AI agent project',
+        'created_at': datetime.utcnow().isoformat(),
+
+        # Project components (will be populated as user creates them)
+        'agents': [],
+        'workflows': []
+    }
+    
+    config_file = project_dir / 'daita-project.yaml'
+    with open(config_file, 'w') as f:
+        yaml.dump(config, f, default_flow_style=False, sort_keys=False)
+    
+    if verbose:
+        print(f"    Created: daita-project.yaml")
+
+def _create_starter_files(project_dir, project_name, verbose):
+    """Create minimal starter agent and workflow files."""
+    
+    # Simple starter agent
+    starter_agent = '''"""
+My Agent
+
+A simple starter agent. Replace this with your own logic.
+"""
+from daita import SubstrateAgent
+
+def create_agent():
+    """Create the agent instance using direct SubstrateAgent pattern."""
+    # Option 1: Simple instantiation (uses defaults)
+    agent = SubstrateAgent(name="My Agent")
+    
+    # Option 2: Direct LLM configuration (uncomment and modify as needed)
+    # import os
+    # agent = SubstrateAgent(
+    #     name="My Agent",
+    #     llm_provider="openai",
+    #     model="gpt-4",
+    #     api_key=os.getenv("OPENAI_API_KEY")
+    # )
+    
+    # Optional: Add plugins
+    # from daita.plugins import postgresql
+    # agent.add_plugin(postgresql(host="localhost", database="mydb"))
+    
+    return agent
+
+if __name__ == "__main__":
+    import asyncio
+    
+    async def main():
+        agent = create_agent()
+        result = await agent.process("test_task", "Hello, world!")
+        print(result)
+    
+    asyncio.run(main())
+'''
+    
+    # Simple starter workflow
+    starter_workflow = '''"""
+My Workflow
+
+A simple starter workflow. Replace this with your own logic.
+"""
+from daita import SubstrateAgent, Workflow
+
+def create_workflow():
+    """Create the workflow instance using direct Workflow pattern."""
+    workflow = Workflow("My Workflow")
+    
+    # Add your agents here
+    # agent = SubstrateAgent(name="Agent")
+    # workflow.add_agent("agent", agent)
+    
+    return workflow
+
+async def run_workflow(data=None):
+    """Run the workflow with direct pattern."""
+    workflow = create_workflow()
+    
+    try:
+        await workflow.start()
+        
+        # Your workflow logic here
+        result = f"Workflow processed: {data}"
+        
+        return {
+            'status': 'success',
+            'result': result
+        }
+        
+    finally:
+        await workflow.stop()
+
+if __name__ == "__main__":
+    import asyncio
+    
+    async def main():
+        result = await run_workflow("Hello, workflow!")
+        print(result)
+    
+    asyncio.run(main())
+'''
+    
+    # Write starter files
+    (project_dir / 'agents' / 'my_agent.py').write_text(starter_agent)
+    (project_dir / 'workflows' / 'my_workflow.py').write_text(starter_workflow)
+    
+    if verbose:
+        print(f"    Created: agents/my_agent.py")
+        print(f"    Created: workflows/my_workflow.py")
+
+def _create_supporting_files(project_dir, project_name, verbose):
+    """Create supporting files (requirements, README, etc.)."""
+    
+    # Minimal requirements.txt
+    requirements = '''# Daita Agents Framework
+daita-agents>=0.1.0
+
+# LLM provider (choose one)
+openai>=1.0.0
+
+# Development
+pytest>=7.0.0
+pytest-asyncio>=0.21.0
+'''
+    
+    # Simple .gitignore
+    gitignore = '''# Python
+__pycache__/
+*.py[cod]
+*.so
+.Python
+build/
+dist/
+*.egg-info/
+
+# Virtual environments
+.env
+.venv
+venv/
+
+# IDE
+.vscode/
+.idea/
+
+# OS
+.DS_Store
+
+# API keys
+.env.local
+'''
+    
+    # README with freemium messaging
+    readme = f'''# {project_name}
+
+A Daita AI agent project.
+
+## Quick Setup
+
+1. Install dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+2. Set your LLM API key:
+   ```bash
+   export OPENAI_API_KEY=your_key_here
+   ```
+
+## Free Local Development
+
+Build and test your agents locally - completely free:
+
+```bash
+# Test the example agent
+python agents/my_agent.py
+
+# Test all components
+daita test
+
+# Watch for changes while developing
+daita test --watch
+
+# Create new components
+daita create agent my_new_agent
+daita create workflow my_new_workflow
+```
+
+## Production Cloud Hosting
+
+Ready to deploy to the cloud? Get 24/7 hosting, monitoring, and insights:
+
+```bash
+# Get your API key at daita-tech.io
+export DAITA_API_KEY='your-key-here'
+
+# Deploy to cloud
+daita push                   # Deploy to production
+
+# Monitor your deployments
+daita status                 # Deployment status
+daita logs                   # View execution logs
+```
+
+## Project Structure
+
+```
+{project_name}/
+├── agents/          # Your AI agents (free to create & test)
+│   └── my_agent.py
+├── workflows/       # Your workflows (free to create & test)
+│   └── my_workflow.py
+├── data/           # Data files
+├── tests/          # Tests
+└── daita-project.yaml  # Project config
+```
+
+## Command Reference
+
+**Free Commands (Local Development):**
+- `daita test` - Test all agents and workflows
+- `daita test --watch` - Development mode with auto-reload
+- `daita create agent <name>` - Create new agent
+- `daita create workflow <name>` - Create new workflow
+
+**Premium Commands (Cloud Hosting):**
+- `daita push <env>` - Deploy to cloud
+- `daita status` - Monitor deployments
+- `daita logs <env>` - View execution logs
+- `daita run <agent>` - Execute remotely
+
+## Learn More
+
+-  [Get API Key](https://daita-tech.io) - Start your free trial
+-  [Documentation](https://docs.daita-tech.io)
+'''
+    
+    # Simple test file
+    test_file = '''"""
+Basic test for your agents and workflows.
+"""
+import pytest
+import asyncio
+
+# Example test - replace with your own
+@pytest.mark.asyncio
+async def test_my_agent():
+    """Test the example agent."""
+    from agents.my_agent import create_agent
+    
+    agent = create_agent()
+    result = await agent.process("test data")
+    
+    assert result["status"] == "success"
+    assert "test data" in result["result"]
+
+@pytest.mark.asyncio  
+async def test_my_workflow():
+    """Test the example workflow."""
+    from workflows.my_workflow import create_workflow
+    
+    workflow = create_workflow()
+    result = await workflow.run("test data")
+    
+    assert result["status"] == "success"
+
+if __name__ == "__main__":
+    # Run tests directly
+    asyncio.run(test_my_agent())
+    asyncio.run(test_my_workflow())
+    print(" All tests passed!")
+'''
+    
+    # Write all supporting files
+    (project_dir / 'requirements.txt').write_text(requirements)
+    (project_dir / '.gitignore').write_text(gitignore)
+    (project_dir / 'README.md').write_text(readme)
+    (project_dir / 'tests' / 'test_basic.py').write_text(test_file)
+    
+    # Create empty data directory with placeholder
+    (project_dir / 'data' / '.gitkeep').write_text('')
+    
+    if verbose:
+        print(f"    Created: requirements.txt")
+        print(f"    Created: .gitignore")
+        print(f"    Created: README.md")
+        print(f"    Created: tests/test_basic.py")
+

daita/cli/core/logs.py

@@ -0,0 +1,239 @@
+"""
+Simple logs display for Daita CLI.
+Shows deployment history and logs like git log from cloud API.
+"""
+import os
+import aiohttp
+from datetime import datetime
+from ..utils import find_project_root
+
+
+async def show_deployment_logs(environment=None, limit=10, follow=False, verbose=False):
+   """Show deployment logs (like git log) from cloud API."""
+
+   # Check API key first
+   api_key = os.getenv('DAITA_API_KEY')
+   if not api_key:
+       from ..utils import show_upgrade_message
+       show_upgrade_message()
+       return
+
+   # Get current project name for display
+   project_root = find_project_root()
+   current_project = None
+   if project_root:
+       import yaml
+       config_file = project_root / 'daita-project.yaml'
+       if config_file.exists():
+           try:
+               with open(config_file, 'r') as f:
+                   config = yaml.safe_load(f)
+                   current_project = config.get('name')
+           except:
+               current_project = None
+
+   # Load deployments from cloud API
+   deployments, api_error = await _load_cloud_deployments(environment, limit)
+
+   if api_error:
+       print(f" Failed to fetch deployments: {api_error}")
+       if verbose:
+           print(f"   API Key: {api_key[:20]}...")
+           print(f"   Endpoint: {os.getenv('DAITA_API_ENDPOINT', 'https://api.daita.ai')}")
+       return
+
+   if not deployments:
+       if current_project:
+           if environment:
+               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")
+       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")
+       return
+
+   # Filter by environment if specified (additional client-side filtering)
+   if environment:
+       deployments = [d for d in deployments if d['environment'] == environment]
+       if not deployments:
+           print(f" No deployments found for environment: {environment}")
+           return
+
+   # Take most recent deployments (API already returns newest first)
+   deployments = deployments[:limit]
+
+   # Find the most recent active deployment
+   latest_active_deployment = None
+   for deployment in deployments:
+       if deployment.get('status') == 'active':
+           latest_active_deployment = deployment
+           break
+
+   # Build header with scope indication
+   header_parts = []
+   if current_project:
+       header_parts.append(current_project)
+   if environment:
+       header_parts.append(environment)
+
+   if header_parts:
+       scope_info = f" ({', '.join(header_parts)})"
+   elif current_project is None:
+       scope_info = " (Organization)"
+   else:
+       scope_info = ""
+
+   print(f" Deployment History{scope_info}")
+   print("")
+
+   for i, deployment in enumerate(deployments):
+       is_current = (latest_active_deployment and
+                    deployment.get('deployment_id') == latest_active_deployment.get('deployment_id'))
+       _show_deployment(deployment, verbose, is_latest=is_current)
+       if i < len(deployments) - 1:
+           print("")
+
+   if follow:
+       print(f"\n  Following logs... (Press Ctrl+C to stop)")
+       try:
+           import asyncio
+           while True:
+               await asyncio.sleep(5)
+               # Check for new deployments
+               new_deployments, error = await _load_cloud_deployments(environment, limit)
+               if error:
+                   continue  # Skip this check if API fails
+
+               if len(new_deployments) > len(deployments):
+                   latest = new_deployments[-1]
+                   print(f"\n New deployment:")
+                   _show_deployment(latest, verbose, is_latest=True)
+                   deployments = new_deployments
+       except KeyboardInterrupt:
+           print(f"\n Stopped following logs")
+
+def _show_deployment(deployment, verbose, is_latest=False):
+   """Show a single deployment entry."""
+   env = deployment['environment']
+   timestamp = deployment['deployed_at']
+   version = deployment.get('version', '1.0.0')
+   project = deployment.get('project_name', 'Unknown')
+
+   # Format timestamp
+   if timestamp:
+       # Handle ISO format from API
+       if 'T' in timestamp:
+           dt = datetime.fromisoformat(timestamp.replace('Z', '+00:00'))
+           time_str = dt.strftime('%Y-%m-%d %H:%M:%S')
+       else:
+           time_str = timestamp
+   else:
+       time_str = 'Unknown time'
+
+   # Status indicator
+   status = "●" if is_latest else "○"
+   current = " (current)" if is_latest else ""
+
+   print(f"{status} {env}: {project} v{version}{current}")
+   print(f"    {time_str}")
+
+   if verbose:
+       # Show detailed info
+       agents = deployment.get('agents_config', [])
+       workflows = deployment.get('workflows_config', [])
+
+       if agents:
+           agent_names = [agent.get('name', 'unknown') for agent in agents]
+           print(f"    Agents: {', '.join(agent_names)}")
+       if workflows:
+           workflow_names = [wf.get('name', 'unknown') for wf in workflows]
+           print(f"    Workflows: {', '.join(workflow_names)}")
+
+       # Show deployment ID
+       deploy_id = deployment.get('deployment_id', 'N/A')
+       if len(deploy_id) > 8:
+           deploy_id = deploy_id[:8]  # Show first 8 characters
+       print(f"    ID: {deploy_id}")
+
+       # Show status
+       status = deployment.get('status', 'unknown')
+       print(f"    Status: {status}")
+
+async def _load_cloud_deployments(environment=None, limit=10):
+   """Load deployment history from cloud API."""
+   try:
+       api_key = os.getenv('DAITA_API_KEY')
+       if not api_key:
+           return [], "API key not found"
+
+       # Get current project name to filter deployments when in project directory
+       project_root = find_project_root()
+       if project_root:
+           import yaml
+           config_file = project_root / 'daita-project.yaml'
+           current_project = None
+           if config_file.exists():
+               try:
+                   with open(config_file, 'r') as f:
+                       config = yaml.safe_load(f)
+                       current_project = config.get('name')
+               except:
+                   current_project = None
+       else:
+           current_project = None
+
+       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:
+           # Build URL with filters
+           url = f"{api_endpoint}/api/v1/deployments/api-key"
+           params = {}
+           if environment:
+               params['environment'] = environment
+           if current_project:
+               params['project_name'] = current_project
+           if limit and limit != 10:
+               params['per_page'] = min(limit, 100)  # API limit
+
+           async with session.get(url, headers=headers, params=params, timeout=30) as response:
+               if response.status == 200:
+                   data = await response.json()
+
+                   # Handle paginated response from API (like in status.py)
+                   if isinstance(data, dict) and 'deployments' in data:
+                       deployments = data['deployments']
+                   else:
+                       deployments = data if isinstance(data, list) else []
+
+                   # Return deployments in API format (no conversion needed)
+                   return deployments, None
+               elif response.status == 401:
+                   return [], "Invalid API key"
+               elif response.status == 403:
+                   return [], "Access denied - check API key permissions"
+               else:
+                   error_text = await response.text()
+                   return [], f"API error {response.status}: {error_text[:100]}"
+   except Exception as e:
+       if "timeout" in str(e).lower():
+           return [], "Request timeout - check your connection"
+       elif "dns" in str(e).lower() or "name" in str(e).lower():
+           return [], f"Cannot resolve API endpoint - check DAITA_API_ENDPOINT setting"
+       else:
+           return [], f"Network error: {str(e)}"
+
+def _get_deployment_id(deployment):
+   """Generate short deployment ID."""
+   import hashlib
+   content = f"{deployment['deployed_at']}{deployment['environment']}"
+   return hashlib.md5(content.encode()).hexdigest()[:8]