daita-agents 0.1.0__py3-none-any.whl

daita/cli/__init__.py

@@ -0,0 +1,145 @@
+"""
+Daita CLI - Command Line Interface for Daita Agents.
+
+Simple, git-like CLI for building and deploying AI agents.
+
+Example usage:
+    # Initialize a new project
+    daita init my-project --type analysis
+    
+    # Create components
+    daita create agent data_processor
+    daita create workflow data_pipeline
+    
+    # Test and develop
+    daita test
+    daita test --watch
+    
+    # Deploy
+    daita push staging
+    daita push production --force
+    
+    # Monitor
+    daita status
+    daita logs production
+"""
+
+# CLI version
+__version__ = "0.1.0"
+
+# Import main CLI components
+from .main import cli, main
+
+# Import core functions for programmatic access
+from .core.init import initialize_project
+from .core.create import create_from_template
+from .core.test import run_tests
+from .core.deploy import deploy_to_environment
+from .core.status import show_project_status
+from .core.logs import show_deployment_logs
+
+# Export main components
+__all__ = [
+    # Version
+    '__version__',
+    
+    # Main CLI
+    'cli',
+    'main',
+    
+    # Core functions (for programmatic access)
+    'initialize_project',
+    'create_from_template',
+    'run_tests',
+    'deploy_to_environment',
+    'show_project_status',
+    'show_deployment_logs',
+]
+
+# CLI metadata
+CLI_INFO = {
+    'name': 'daita',
+    'version': __version__,
+    'description': 'CLI for AI agent development and deployment',
+    'author': 'Daita Team',
+    'docs': 'https://docs.daita-tech.io',
+}
+
+def get_cli_info() -> dict:
+    """
+    Get CLI information and metadata.
+    
+    Returns:
+        Dictionary with CLI information
+    """
+    return CLI_INFO.copy()
+
+def print_banner():
+    """Print CLI banner with version information."""
+    print(f"""
+╔══════════════════════════════════════════════╗
+║                 Daita CLI                    ║
+║          AI Agent Framework CLI              ║
+║                                              ║
+║  Version: {__version__:<31} ║
+║  Docs: https://docs.daita-tech.io/cli             ║
+╚══════════════════════════════════════════════╝
+""")
+
+# Convenience functions for common operations
+def quick_init(project_name: str = None, project_type: str = 'basic') -> None:
+    """
+    Quick project initialization.
+    
+    Args:
+        project_name: Name of the project
+        project_type: Type of project (basic, analysis, pipeline)
+    """
+    import asyncio
+    
+    asyncio.run(initialize_project(
+        project_name=project_name,
+        project_type=project_type,
+        verbose=False
+    ))
+
+def quick_status() -> dict:
+    """
+    Quick status check for current project.
+    
+    Returns:
+        Dictionary with project status information
+    """
+    import asyncio
+    from .utils import find_project_root
+    
+    project_root = find_project_root()
+    if not project_root:
+        return {"error": "Not in a Daita project"}
+    
+    # This would return status info - simplified for MVP
+    return {
+        "project_root": str(project_root),
+        "status": "active"
+    }
+
+def quick_test(target: str = None) -> bool:
+    """
+    Quick test runner.
+    
+    Args:
+        target: Specific agent or workflow to test
+        
+    Returns:
+        True if tests passed, False otherwise
+    """
+    import asyncio
+    
+    try:
+        asyncio.run(run_tests(
+            target=target,
+            verbose=False
+        ))
+        return True
+    except Exception:
+        return False

daita/cli/__main__.py

@@ -0,0 +1,7 @@
+"""
+Main entry point for python -m daita.cli
+"""
+from .main import main
+
+if __name__ == '__main__':
+    main()

daita/cli/ascii_art.py

@@ -0,0 +1,44 @@
+"""
+ASCII art utilities for Daita CLI.
+"""
+
+def get_daita_ascii_art():
+    """Return the main DAITA ASCII art."""
+    return """
+██████╗  █████╗ ██╗████████╗ █████╗ 
+██╔══██╗██╔══██╗██║╚══██╔══╝██╔══██╗
+██║  ██║███████║██║   ██║   ███████║
+██║  ██║██╔══██║██║   ██║   ██╔══██║
+██████╔╝██║  ██║██║   ██║   ██║  ██║
+╚═════╝ ╚═╝  ╚═╝╚═╝   ╚═╝   ╚═╝  ╚═╝
+
+    AI Agent Framework & Platform
+"""
+
+def get_compact_daita_logo():
+    """Return a compact DAITA logo for smaller displays."""
+    return """
+█▀▄ ▄▀█ █ ▀█▀ ▄▀█
+█▄▀ █▀█ █  █  █▀█  Agents
+"""
+
+def display_welcome_banner():
+    """Display the full welcome banner with ASCII art."""
+    print(get_daita_ascii_art())
+
+def display_compact_banner():
+    """Display the compact banner."""
+    print(get_compact_daita_logo())
+
+def get_version_banner(version="0.1.0"):
+    """Get version banner with ASCII art."""
+    return f"""{get_daita_ascii_art()}
+                 v{version}
+     Build, test, and deploy AI agents
+"""
+
+def get_success_banner(message="Project created successfully!"):
+    """Get success banner with ASCII art."""
+    return f"""{get_daita_ascii_art()}
+    ✨ {message}
+"""

daita/cli/core/create.py

@@ -0,0 +1,254 @@
+"""
+Simple component creation for Daita CLI.
+Creates basic agents and workflows with proper path handling.
+"""
+import os
+from pathlib import Path
+from ..utils import find_project_root
+
+def create_from_template(template, name=None, variant=None, verbose=False):
+    """Create a component from a template."""
+    
+    # Find project root
+    project_root = find_project_root()
+    if not project_root:
+        raise ValueError("Not in a Daita project. Run 'daita init' first.")
+    
+    # Get name if not provided
+    if not name:
+        name = input(f"Enter {template} name: ").strip()
+    
+    # Validate name
+    if not name or not name.replace('_', '').replace('-', '').isalnum():
+        raise ValueError(f"Invalid {template} name: {name}")
+    
+    # Convert name to valid Python identifier
+    clean_name = name.replace('-', '_').lower()
+    
+    # Create the component
+    if template == 'agent':
+        _create_agent(project_root, clean_name, verbose)
+    elif template == 'workflow':
+        _create_workflow(project_root, clean_name, verbose)
+    else:
+        raise ValueError(f"Unknown template: {template}")
+    
+    print(f" Created {template}: {clean_name}")
+
+def _create_agent(project_root, name, verbose=False):
+    """Create a simple agent."""
+    class_name = _to_class_name(name)
+    
+    code = f'''"""
+{class_name} Agent
+
+Replace this with your own agent 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="{class_name}")
+    
+    # Option 2: Direct LLM configuration (uncomment and modify as needed)
+    # import os
+    # agent = SubstrateAgent(
+    #     name="{class_name}",
+    #     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())
+'''
+    
+    # Ensure agents directory exists
+    agents_dir = project_root / 'agents'
+    agents_dir.mkdir(exist_ok=True)
+    
+    # Create agent file
+    agent_file = agents_dir / f'{name}.py'
+    
+    if agent_file.exists():
+        raise ValueError(f"Agent {name} already exists")
+    
+    agent_file.write_text(code)
+    
+    # Prompt for display name
+    default_display = name.replace('_', ' ').title()
+    print(f"\n  Display name for deployment:")
+    try:
+        display_name = input(f"   Press Enter for '{default_display}' or type custom name: ").strip()
+        if not display_name:
+            display_name = default_display
+    except (EOFError, KeyboardInterrupt):
+        # Non-interactive environment or user cancelled
+        display_name = default_display
+        print(f"   Using default: '{default_display}'")
+    except Exception:
+        # Any other input error
+        display_name = default_display
+        print(f"   Input error, using default: '{default_display}'")
+    
+    # Update project config with display name
+    _update_project_config(project_root, 'agents', name, display_name)
+    
+    if verbose:
+        print(f"    Created: {agent_file.relative_to(project_root)}")
+        print(f"    Updated project config")
+    
+    print(f"     Display name: '{display_name}'")
+
+def _create_workflow(project_root, name, verbose=False):
+    """Create a simple workflow."""
+    class_name = _to_class_name(name)
+    
+    code = f'''"""
+{class_name} Workflow
+
+Replace this with your own workflow logic.
+"""
+from daita import SubstrateAgent, Workflow
+
+class {class_name}:
+    """A simple workflow."""
+    
+    def __init__(self):
+        self.workflow = Workflow("{name}")
+        
+        # Add your agents here
+        # agent = SubstrateAgent(name="Agent")
+        # self.workflow.add_agent("agent", agent)
+    
+    async def run(self, data=None):
+        """
+        Run the workflow.
+        
+        Replace this with your own logic.
+        """
+        try:
+            await self.workflow.start()
+            
+            # Your workflow logic here
+            result = f"Workflow {class_name} processed: {{data}}"
+            
+            return {{
+                'status': 'success',
+                'result': result
+            }}
+            
+        finally:
+            await self.workflow.stop()
+
+def create_workflow():
+    """Create the workflow instance."""
+    return {class_name}()
+
+if __name__ == "__main__":
+    import asyncio
+    
+    async def main():
+        workflow = {class_name}()
+        result = await workflow.run("test data")
+        print(result)
+    
+    asyncio.run(main())
+'''
+    
+    # Ensure workflows directory exists
+    workflows_dir = project_root / 'workflows'
+    workflows_dir.mkdir(exist_ok=True)
+    
+    # Create workflow file
+    workflow_file = workflows_dir / f'{name}.py'
+    
+    if workflow_file.exists():
+        raise ValueError(f"Workflow {name} already exists")
+    
+    workflow_file.write_text(code)
+    
+    # Prompt for display name
+    default_display = name.replace('_', ' ').title()
+    print(f"\n  Display name for deployment:")
+    try:
+        display_name = input(f"   Press Enter for '{default_display}' or type custom name: ").strip()
+        if not display_name:
+            display_name = default_display
+    except (EOFError, KeyboardInterrupt):
+        # Non-interactive environment or user cancelled
+        display_name = default_display
+        print(f"   Using default: '{default_display}'")
+    except Exception:
+        # Any other input error
+        display_name = default_display
+        print(f"   Input error, using default: '{default_display}'")
+    
+    # Update project config with display name
+    _update_project_config(project_root, 'workflows', name, display_name)
+    
+    if verbose:
+        print(f"    Created: {workflow_file.relative_to(project_root)}")
+        print(f"    Updated project config")
+    
+    print(f"     Display name: '{display_name}'")
+
+
+def _update_project_config(project_root, component_type, name, display_name=None):
+    """Update daita-project.yaml with new component."""
+    import yaml
+    from datetime import datetime
+    
+    config_file = project_root / 'daita-project.yaml'
+    
+    if config_file.exists():
+        with open(config_file, 'r') as f:
+            config = yaml.safe_load(f)
+    else:
+        config = {}
+    
+    # Ensure arrays exist
+    if component_type not in config:
+        config[component_type] = []
+    
+    # Generate default display name if not provided
+    if not display_name:
+        display_name = name.replace('_', ' ').title()
+    
+    # Add component if not already present
+    component_entry = {
+        'name': name,
+        'display_name': display_name,
+        'type': 'substrate' if component_type == 'agents' else 'basic',
+        'created_at': datetime.now().isoformat()
+    }
+    
+    # Check if already exists
+    existing = next((c for c in config[component_type] if c['name'] == name), None)
+    if not existing:
+        config[component_type].append(component_entry)
+        
+        # Write back to file
+        with open(config_file, 'w') as f:
+            yaml.dump(config, f, default_flow_style=False)
+
+
+def _to_class_name(name):
+    """Convert snake_case or kebab-case to PascalCase."""
+    # Split on underscores and hyphens, capitalize each part
+    parts = name.replace('-', '_').split('_')
+    return ''.join(word.capitalize() for word in parts if word)