ainative-python 2.0.0__py3-none-any.whl

ainative/client.py

@@ -0,0 +1,272 @@
+"""
+AINative SDK Main Client
+
+Core client for interacting with AINative Studio APIs.
+"""
+
+from typing import Optional, Dict, Any, Union
+import httpx
+from urllib.parse import urljoin
+import json
+import time
+from dataclasses import dataclass
+
+from .auth import AuthConfig, APIKeyAuth
+from .exceptions import (
+    APIError,
+    NetworkError,
+    RateLimitError,
+    AuthenticationError,
+)
+from .zerodb import ZeroDBClient
+from .agent_swarm import AgentSwarmClient
+from .agent_orchestration import AgentOrchestrationClient
+from .agent_coordination import AgentCoordinationClient
+from .agent_learning import AgentLearningClient
+from .agent_state import AgentStateClient
+
+
+@dataclass
+class ClientConfig:
+    """Configuration for the AINative client."""
+    
+    base_url: str = "https://api.ainative.studio"
+    timeout: int = 30
+    max_retries: int = 3
+    retry_delay: float = 1.0
+    verify_ssl: bool = True
+    debug: bool = False
+    
+    def __post_init__(self):
+        """Validate and normalize configuration."""
+        # Ensure base URL doesn't end with slash
+        self.base_url = self.base_url.rstrip("/")
+        
+        # Add API version if not present (and doesn't already contain /api/)
+        if "/api/" not in self.base_url:
+            self.base_url = f"{self.base_url}/api/v1"
+
+
+class AINativeClient:
+    """Main client for AINative Studio API operations."""
+    
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        api_secret: Optional[str] = None,
+        base_url: Optional[str] = None,
+        organization_id: Optional[str] = None,
+        config: Optional[ClientConfig] = None,
+        auth_config: Optional[AuthConfig] = None,
+    ):
+        """
+        Initialize AINative client.
+        
+        Args:
+            api_key: Your AINative API key
+            api_secret: Your AINative API secret (optional, for enhanced security)
+            base_url: Override default API base URL
+            organization_id: Organization ID for multi-tenant scenarios
+            config: Custom client configuration
+            auth_config: Custom authentication configuration
+        """
+        # Set up configuration
+        self.config = config or ClientConfig()
+        if base_url:
+            self.config.base_url = base_url
+        
+        # Set up authentication
+        if auth_config:
+            self.auth_config = auth_config
+        else:
+            self.auth_config = AuthConfig(
+                api_key=api_key,
+                api_secret=api_secret,
+            )
+        
+        self.auth = APIKeyAuth(self.auth_config)
+        self.organization_id = organization_id
+        
+        # Initialize HTTP client
+        self._client = httpx.Client(
+            timeout=self.config.timeout,
+            verify=self.config.verify_ssl,
+        )
+        
+        # Initialize sub-clients
+        self._zerodb: Optional[ZeroDBClient] = None
+        self._agent_swarm: Optional[AgentSwarmClient] = None
+        self._agent_orchestration: Optional[AgentOrchestrationClient] = None
+        self._agent_coordination: Optional[AgentCoordinationClient] = None
+        self._agent_learning: Optional[AgentLearningClient] = None
+        self._agent_state: Optional[AgentStateClient] = None
+    
+    @property
+    def zerodb(self) -> ZeroDBClient:
+        """Get ZeroDB operations client."""
+        if not self._zerodb:
+            self._zerodb = ZeroDBClient(self)
+        return self._zerodb
+    
+    @property
+    def agent_swarm(self) -> AgentSwarmClient:
+        """Get Agent Swarm operations client."""
+        if not self._agent_swarm:
+            self._agent_swarm = AgentSwarmClient(self)
+        return self._agent_swarm
+
+    @property
+    def agent_orchestration(self) -> AgentOrchestrationClient:
+        """Get Agent Orchestration operations client."""
+        if not self._agent_orchestration:
+            self._agent_orchestration = AgentOrchestrationClient(self)
+        return self._agent_orchestration
+
+    @property
+    def agent_coordination(self) -> AgentCoordinationClient:
+        """Get Agent Coordination operations client."""
+        if not self._agent_coordination:
+            self._agent_coordination = AgentCoordinationClient(self)
+        return self._agent_coordination
+
+    @property
+    def agent_learning(self) -> AgentLearningClient:
+        """Get Agent Learning operations client."""
+        if not self._agent_learning:
+            self._agent_learning = AgentLearningClient(self)
+        return self._agent_learning
+
+    @property
+    def agent_state(self) -> AgentStateClient:
+        """Get Agent State operations client."""
+        if not self._agent_state:
+            self._agent_state = AgentStateClient(self)
+        return self._agent_state
+    
+    def request(
+        self,
+        method: str,
+        endpoint: str,
+        data: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Make an authenticated request to the API.
+        
+        Args:
+            method: HTTP method (GET, POST, PUT, DELETE, etc.)
+            endpoint: API endpoint path
+            data: Request body data
+            params: Query parameters
+            headers: Additional headers
+            **kwargs: Additional arguments for httpx
+        
+        Returns:
+            Response data as dictionary
+        
+        Raises:
+            APIError: For API-related errors
+            NetworkError: For network-related errors
+            RateLimitError: When rate limit is exceeded
+        """
+        # Build full URL
+        url = urljoin(self.config.base_url, endpoint.lstrip("/"))
+        
+        # Prepare headers
+        request_headers = self.auth.get_headers()
+        if headers:
+            request_headers.update(headers)
+        
+        # Add organization ID if set
+        if self.organization_id:
+            request_headers["X-Organization-ID"] = self.organization_id
+        
+        # Make request with retries
+        last_error = None
+        for attempt in range(self.config.max_retries):
+            try:
+                response = self._client.request(
+                    method=method,
+                    url=url,
+                    json=data,
+                    params=params,
+                    headers=request_headers,
+                    **kwargs
+                )
+                
+                # Handle rate limiting
+                if response.status_code == 429:
+                    retry_after = int(response.headers.get("Retry-After", 60))
+                    raise RateLimitError(retry_after=retry_after)
+                
+                # Handle authentication errors
+                if response.status_code == 401:
+                    raise AuthenticationError("Invalid API credentials")
+                
+                # Handle other errors
+                if response.status_code >= 400:
+                    raise APIError(
+                        f"API error: {response.status_code}",
+                        status_code=response.status_code,
+                        response_body=response.text,
+                    )
+                
+                # Parse and return response
+                if response.text:
+                    return response.json()
+                return {}
+                
+            except httpx.NetworkError as e:
+                last_error = NetworkError(f"Network error: {str(e)}")
+                if attempt < self.config.max_retries - 1:
+                    time.sleep(self.config.retry_delay * (attempt + 1))
+                    continue
+                raise last_error
+            
+            except httpx.TimeoutException:
+                last_error = NetworkError("Request timed out")
+                if attempt < self.config.max_retries - 1:
+                    time.sleep(self.config.retry_delay * (attempt + 1))
+                    continue
+                raise last_error
+        
+        if last_error:
+            raise last_error
+    
+    def get(self, endpoint: str, **kwargs) -> Dict[str, Any]:
+        """Make a GET request."""
+        return self.request("GET", endpoint, **kwargs)
+    
+    def post(self, endpoint: str, data: Optional[Dict[str, Any]] = None, **kwargs) -> Dict[str, Any]:
+        """Make a POST request."""
+        return self.request("POST", endpoint, data=data, **kwargs)
+    
+    def put(self, endpoint: str, data: Optional[Dict[str, Any]] = None, **kwargs) -> Dict[str, Any]:
+        """Make a PUT request."""
+        return self.request("PUT", endpoint, data=data, **kwargs)
+    
+    def delete(self, endpoint: str, **kwargs) -> Dict[str, Any]:
+        """Make a DELETE request."""
+        return self.request("DELETE", endpoint, **kwargs)
+    
+    def patch(self, endpoint: str, data: Optional[Dict[str, Any]] = None, **kwargs) -> Dict[str, Any]:
+        """Make a PATCH request."""
+        return self.request("PATCH", endpoint, data=data, **kwargs)
+    
+    def health_check(self) -> Dict[str, Any]:
+        """Check API health status."""
+        return self.get("/health")
+    
+    def close(self):
+        """Close the HTTP client connection."""
+        self._client.close()
+    
+    def __enter__(self):
+        """Context manager entry."""
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        self.close()

ainative/commands/__init__.py

@@ -0,0 +1,28 @@
+"""
+AINative CLI Module
+
+Modular CLI structure with separate command groups.
+"""
+
+from .agents import agents_group
+from .swarm import swarm_group
+from .tasks import task_group
+from .coordination import coordination_group
+from .learning import learning_group
+from .state import state_group
+from .local import local_group
+from .inspect import inspect_group
+from .sync import sync_group
+
+
+__all__ = [
+    "agents_group",
+    "swarm_group",
+    "task_group",
+    "coordination_group",
+    "learning_group",
+    "state_group",
+    "local_group",
+    "inspect_group",
+    "sync_group",
+]

ainative/commands/agents.py

@@ -0,0 +1,238 @@
+"""
+Agent Identity CLI Commands
+
+Commands for managing agent identities (list, show, create, export, preview).
+"""
+
+import click
+import json
+import yaml
+from pathlib import Path
+from typing import Optional
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+from ..agent_identity_system import AgentRegistry, AgentIdentity, SeedPrompt
+
+
+console = Console()
+
+
+@click.group(name="agents")
+def agents_group():
+    """Manage agent identities and configurations."""
+    pass
+
+
+@agents_group.command(name="list")
+@click.option("--format", type=click.Choice(["table", "json"]), default="table",
+              help="Output format")
+def list_agents(format: str):
+    """List all available agent identities."""
+    try:
+        registry = AgentRegistry()
+        agent_ids = registry.list_agents()
+
+        if format == "json":
+            output = []
+            for agent_id in agent_ids:
+                agent = registry.get_identity(agent_id)
+                output.append({
+                    "id": agent.id,
+                    "name": agent.name,
+                    "role": agent.role_title,
+                    "emoji": agent.emoji,
+                })
+            click.echo(json.dumps(output, indent=2))
+        else:
+            table = Table(title="Agent Identities")
+            table.add_column("ID", style="cyan")
+            table.add_column("Name", style="bold")
+            table.add_column("Role", style="dim")
+            table.add_column("Emoji", justify="center")
+
+            for agent_id in agent_ids:
+                agent = registry.get_identity(agent_id)
+                table.add_row(
+                    agent.id,
+                    agent.name,
+                    agent.role_title,
+                    agent.emoji
+                )
+
+            console.print(table)
+
+    except Exception as e:
+        click.echo(f"Error: {str(e)}", err=True)
+
+
+@agents_group.command(name="show")
+@click.argument("agent_id")
+@click.option("--format", type=click.Choice(["panel", "json"]), default="panel",
+              help="Output format")
+def show_agent(agent_id: str, format: str):
+    """Show detailed information about an agent."""
+    try:
+        registry = AgentRegistry()
+        agent = registry.get_identity(agent_id)
+
+        if not agent:
+            click.echo(f"Error: Agent '{agent_id}' not found", err=True)
+            return
+
+        if format == "json":
+            output = {
+                "id": agent.id,
+                "name": agent.name,
+                "role_title": agent.role_title,
+                "color": agent.color,
+                "emoji": agent.emoji,
+                "secondary_emoji": agent.secondary_emoji,
+                "expertise": agent.expertise,
+                "temperature": agent.temperature,
+                "thinking_style": agent.thinking_style,
+                "verbosity": agent.verbosity,
+            }
+            click.echo(json.dumps(output, indent=2))
+        else:
+            content = f"""
+[bold]Role:[/bold] {agent.role_title}
+[bold]Emoji:[/bold] {agent.emoji} {agent.secondary_emoji}
+[bold]Color:[/bold] {agent.color}
+[bold]Thinking Style:[/bold] {agent.thinking_style}
+[bold]Temperature:[/bold] {agent.temperature}
+[bold]Verbosity:[/bold] {agent.verbosity}
+
+[bold]Expertise:[/bold]
+{chr(10).join('  • ' + e for e in agent.expertise)}
+            """
+            panel = agent.create_panel(content.strip(), title=f"{agent.emoji} {agent.name}")
+            console.print(panel)
+
+    except Exception as e:
+        click.echo(f"Error: {str(e)}", err=True)
+
+
+@agents_group.command(name="create")
+@click.option("--id", required=True, help="Agent identifier (lowercase, no spaces)")
+@click.option("--name", required=True, help="Display name")
+@click.option("--role", required=True, help="Role title")
+@click.option("--color", required=True, help="Hex color code (e.g., #FF6B6B)")
+@click.option("--emoji", required=True, help="Primary emoji")
+@click.option("--expertise", multiple=True, help="Areas of expertise")
+@click.option("--temperature", type=float, default=0.5, help="Model temperature")
+@click.option("--output", type=click.Path(), help="Output file path (YAML)")
+def create_agent(id: str, name: str, role: str, color: str, emoji: str,
+                expertise: tuple, temperature: float, output: Optional[str]):
+    """Create a new custom agent identity."""
+    try:
+        agent = AgentIdentity(
+            id=id,
+            name=name,
+            role_title=role,
+            color=color,
+            emoji=emoji,
+            expertise=list(expertise),
+            temperature=temperature
+        )
+
+        agent_data = {
+            "id": agent.id,
+            "name": agent.name,
+            "role_title": agent.role_title,
+            "color": agent.color,
+            "emoji": agent.emoji,
+            "secondary_emoji": agent.secondary_emoji,
+            "expertise": agent.expertise,
+            "temperature": agent.temperature,
+            "thinking_style": agent.thinking_style,
+            "verbosity": agent.verbosity,
+        }
+
+        if output:
+            output_path = Path(output)
+            output_path.write_text(yaml.dump(agent_data, default_flow_style=False))
+            click.echo(f"Agent saved to: {output}")
+        else:
+            click.echo(yaml.dump(agent_data, default_flow_style=False))
+
+        console.print(Panel(f"[green]✓[/green] Agent '{name}' created successfully!",
+                           style=color))
+
+    except Exception as e:
+        click.echo(f"Error: {str(e)}", err=True)
+
+
+@agents_group.command(name="export")
+@click.argument("agent_id")
+@click.option("--output", type=click.Path(), help="Output file path")
+@click.option("--format", type=click.Choice(["yaml", "json"]), default="yaml",
+              help="Export format")
+def export_agent(agent_id: str, output: Optional[str], format: str):
+    """Export an agent identity to file."""
+    try:
+        registry = AgentRegistry()
+        agent = registry.get_identity(agent_id)
+
+        if not agent:
+            click.echo(f"Error: Agent '{agent_id}' not found", err=True)
+            return
+
+        agent_data = {
+            "id": agent.id,
+            "name": agent.name,
+            "role_title": agent.role_title,
+            "color": agent.color,
+            "emoji": agent.emoji,
+            "secondary_emoji": agent.secondary_emoji,
+            "expertise": agent.expertise,
+            "temperature": agent.temperature,
+            "thinking_style": agent.thinking_style,
+            "verbosity": agent.verbosity,
+        }
+
+        if format == "json":
+            content = json.dumps(agent_data, indent=2)
+        else:
+            content = yaml.dump(agent_data, default_flow_style=False)
+
+        if output:
+            Path(output).write_text(content)
+            click.echo(f"Agent exported to: {output}")
+        else:
+            click.echo(content)
+
+    except Exception as e:
+        click.echo(f"Error: {str(e)}", err=True)
+
+
+@agents_group.command(name="preview")
+@click.argument("agent_id")
+@click.option("--message", default="Sample output from this agent",
+              help="Test message to display")
+def preview_agent(agent_id: str, message: str):
+    """Preview an agent's visual styling."""
+    try:
+        registry = AgentRegistry()
+        agent = registry.get_identity(agent_id)
+
+        if not agent:
+            click.echo(f"Error: Agent '{agent_id}' not found", err=True)
+            return
+
+        # Show name
+        console.print(agent.format_name())
+        console.print()
+
+        # Show panel with message
+        panel = agent.create_panel(message)
+        console.print(panel)
+        console.print()
+
+        # Show status
+        console.print(agent.format_status("Working on task..."))
+        console.print(agent.format_status("Task completed!"))
+
+    except Exception as e:
+        click.echo(f"Error: {str(e)}", err=True)

ainative/commands/coordination.py

@@ -0,0 +1,108 @@
+"""
+Agent Coordination CLI Commands
+
+Commands for agent coordination (messages, workload, sync).
+"""
+
+import click
+import json
+from typing import Optional
+from rich.console import Console
+from rich.panel import Panel
+
+from ..client import AINativeClient
+
+
+console = Console()
+
+
+def get_client() -> AINativeClient:
+    """Get authenticated client."""
+    import os
+    from ..auth import AuthConfig
+
+    api_key = os.getenv("AINATIVE_API_KEY")
+    if not api_key:
+        raise click.ClickException("AINATIVE_API_KEY environment variable not set")
+
+    return AINativeClient(
+        auth_config=AuthConfig(api_key=api_key),
+        base_url=os.getenv("AINATIVE_BASE_URL"),
+        organization_id=os.getenv("AINATIVE_ORG_ID")
+    )
+
+
+@click.group(name="coord")
+def coordination_group():
+    """Agent coordination operations."""
+    pass
+
+
+@coordination_group.command(name="message")
+@click.option("--from", "from_agent", required=True, help="Sender agent ID")
+@click.option("--to", "to_agent", required=True, help="Recipient agent ID")
+@click.option("--message", required=True, help="Message content")
+@click.option("--type", "msg_type", default="info", help="Message type")
+def send_message(from_agent: str, to_agent: str, message: str, msg_type: str):
+    """Send message between agents."""
+    try:
+        client = get_client()
+        result = client.agent_coordination.send_message(
+            from_agent_id=from_agent,
+            to_agent_id=to_agent,
+            message=message,
+            message_type=msg_type
+        )
+
+        console.print(Panel(
+            f"[green]✓[/green] Message sent",
+            title="Success"
+        ))
+        console.print(json.dumps(result, indent=2))
+
+    except Exception as e:
+        click.echo(f"Error: {str(e)}", err=True)
+
+
+@coordination_group.command(name="workload")
+@click.option("--agent-id", help="Specific agent ID (optional)")
+def get_workload(agent_id: Optional[str]):
+    """Get agent workload statistics."""
+    try:
+        client = get_client()
+        result = client.agent_coordination.get_agent_workload(agent_id=agent_id)
+
+        console.print(Panel(
+            json.dumps(result, indent=2),
+            title="Agent Workload"
+        ))
+
+    except Exception as e:
+        click.echo(f"Error: {str(e)}", err=True)
+
+
+@coordination_group.command(name="distribute")
+@click.option("--tasks", required=True, help="Task IDs (comma-separated)")
+@click.option("--agents", required=True, help="Agent IDs (comma-separated)")
+@click.option("--strategy", default="round_robin", help="Distribution strategy")
+def distribute_workload(tasks: str, agents: str, strategy: str):
+    """Distribute tasks across agents."""
+    try:
+        client = get_client()
+        task_list = [t.strip() for t in tasks.split(",")]
+        agent_list = [a.strip() for a in agents.split(",")]
+
+        result = client.agent_coordination.distribute_workload(
+            tasks=task_list,
+            agents=agent_list,
+            strategy=strategy
+        )
+
+        console.print(Panel(
+            f"[green]✓[/green] Workload distributed",
+            title="Success"
+        ))
+        console.print(json.dumps(result, indent=2))
+
+    except Exception as e:
+        click.echo(f"Error: {str(e)}", err=True)