ainative-python 2.0.0__py3-none-any.whl

ainative/commands/swarm.py

@@ -0,0 +1,184 @@
+"""
+Swarm Management CLI Commands
+
+Commands for managing agent swarms (list, create, delete, scale, analytics).
+"""
+
+import click
+import json
+from typing import Optional
+from rich.console import Console
+from rich.table import Table
+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="swarm")
+def swarm_group():
+    """Manage agent swarms."""
+    pass
+
+
+@swarm_group.command(name="list")
+@click.option("--project-id", help="Filter by project ID")
+@click.option("--status", help="Filter by status")
+@click.option("--format", type=click.Choice(["table", "json"]), default="table",
+              help="Output format")
+def list_swarms(project_id: Optional[str], status: Optional[str], format: str):
+    """List all swarms."""
+    try:
+        client = get_client()
+        result = client.agent_swarm.list_swarms(
+            project_id=project_id,
+            status=status
+        )
+
+        swarms = result.get("swarms", [])
+
+        if format == "json":
+            click.echo(json.dumps(swarms, indent=2))
+        else:
+            table = Table(title="Agent Swarms")
+            table.add_column("ID", style="cyan")
+            table.add_column("Name", style="bold")
+            table.add_column("Status", style="green")
+            table.add_column("Agents", justify="right")
+            table.add_column("Project", style="dim")
+
+            for swarm in swarms:
+                table.add_row(
+                    swarm.get("id", ""),
+                    swarm.get("name", ""),
+                    swarm.get("status", ""),
+                    str(swarm.get("agent_count", 0)),
+                    swarm.get("project_id", "")
+                )
+
+            console.print(table)
+            console.print(f"\nTotal: {len(swarms)} swarms")
+
+    except Exception as e:
+        click.echo(f"Error: {str(e)}", err=True)
+
+
+@swarm_group.command(name="create")
+@click.argument("name")
+@click.option("--project-id", required=True, help="Project ID")
+@click.option("--objective", required=True, help="Swarm objective")
+@click.option("--agents", help="Comma-separated agent types")
+def create_swarm(name: str, project_id: str, objective: str, agents: Optional[str]):
+    """Create a new swarm."""
+    try:
+        client = get_client()
+
+        agent_list = []
+        if agents:
+            for agent_type in agents.split(","):
+                agent_list.append({"type": agent_type.strip()})
+
+        result = client.agent_swarm.start_swarm(
+            project_id=project_id,
+            agents=agent_list,
+            objective=objective,
+            config={"name": name}
+        )
+
+        console.print(Panel(
+            f"[green]✓[/green] Swarm created: {result.get('swarm_id')}",
+            title="Success"
+        ))
+        console.print(json.dumps(result, indent=2))
+
+    except Exception as e:
+        click.echo(f"Error: {str(e)}", err=True)
+
+
+@swarm_group.command(name="delete")
+@click.argument("swarm_id")
+@click.option("--force", is_flag=True, help="Force deletion without cleanup")
+def delete_swarm(swarm_id: str, force: bool):
+    """Delete a swarm."""
+    try:
+        if not force:
+            click.confirm(f"Delete swarm {swarm_id}?", abort=True)
+
+        client = get_client()
+        result = client.agent_swarm.delete_swarm(swarm_id, force=force)
+
+        console.print(Panel(
+            f"[green]✓[/green] Swarm deleted: {swarm_id}",
+            title="Success"
+        ))
+
+    except Exception as e:
+        click.echo(f"Error: {str(e)}", err=True)
+
+
+@swarm_group.command(name="scale")
+@click.argument("swarm_id")
+@click.option("--agents", required=True, help="Agent counts (e.g., researcher=5,coder=3)")
+def scale_swarm(swarm_id: str, agents: str):
+    """Scale swarm agent counts."""
+    try:
+        agent_counts = {}
+        for pair in agents.split(","):
+            agent_type, count = pair.split("=")
+            agent_counts[agent_type.strip()] = int(count)
+
+        client = get_client()
+        result = client.agent_swarm.scale_swarm(swarm_id, agent_counts)
+
+        console.print(Panel(
+            f"[green]✓[/green] Swarm scaled successfully",
+            title="Success"
+        ))
+        console.print(json.dumps(result, indent=2))
+
+    except Exception as e:
+        click.echo(f"Error: {str(e)}", err=True)
+
+
+@swarm_group.command(name="analytics")
+@click.argument("swarm_id")
+@click.option("--time-range", default="7d", help="Time range (1d, 7d, 30d, all)")
+@click.option("--metrics", help="Comma-separated metric types")
+def get_analytics(swarm_id: str, time_range: str, metrics: Optional[str]):
+    """Get swarm analytics."""
+    try:
+        client = get_client()
+
+        metric_list = metrics.split(",") if metrics else None
+        result = client.agent_swarm.get_analytics(
+            swarm_id,
+            metric_types=metric_list,
+            time_range=time_range
+        )
+
+        console.print(Panel(
+            f"Analytics for swarm: {swarm_id}",
+            title="Swarm Analytics"
+        ))
+        console.print(json.dumps(result, indent=2))
+
+    except Exception as e:
+        click.echo(f"Error: {str(e)}", err=True)

ainative/commands/sync.py

@@ -0,0 +1,157 @@
+"""
+Sync CLI Commands
+
+Commands for synchronizing local and cloud database environments.
+"""
+
+import click
+import json
+from typing import Optional
+from rich.console import Console
+
+from ..client import AINativeClient
+from ..cli_utils.diff import DatabaseDiff
+from ..cli_utils.formatters import DiffFormatter
+
+
+console = Console()
+
+
+def get_client(base_url: Optional[str] = None) -> AINativeClient:
+    """Get authenticated client with optional base URL override."""
+    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=base_url,
+        organization_id=os.getenv("AINATIVE_ORG_ID")
+    )
+
+
+@click.group(name="sync")
+def sync_group():
+    """Database synchronization commands."""
+    pass
+
+
+@sync_group.command(name="plan")
+@click.option(
+    "--local-url",
+    default="http://localhost:8000",
+    help="Local API URL (default: http://localhost:8000)"
+)
+@click.option(
+    "--cloud-url",
+    default="https://api.ainative.studio",
+    help="Cloud API URL (default: https://api.ainative.studio)"
+)
+@click.option(
+    "--schema",
+    is_flag=True,
+    help="Show schema diff only"
+)
+@click.option(
+    "--data",
+    is_flag=True,
+    help="Show data diff only"
+)
+@click.option(
+    "--vectors",
+    is_flag=True,
+    help="Show vectors diff only"
+)
+@click.option(
+    "--json",
+    "json_output",
+    is_flag=True,
+    help="Output as JSON"
+)
+def sync_plan(
+    local_url: str,
+    cloud_url: str,
+    schema: bool,
+    data: bool,
+    vectors: bool,
+    json_output: bool
+):
+    """
+    Show diff between local and cloud environments.
+
+    Compares database schema, data, and vectors between local development
+    environment and cloud production. Use flags to filter specific types.
+
+    Examples:
+        ainative sync plan
+        ainative sync plan --schema
+        ainative sync plan --data --vectors
+        ainative sync plan --json
+    """
+    try:
+        # If no specific flags set, show all
+        show_all = not (schema or data or vectors)
+
+        console.print("\n[bold cyan]🔍 Sync Plan (Local → Cloud)[/bold cyan]\n")
+
+        # Fetch data from local and cloud
+        console.print("[dim]Fetching local database state...[/dim]")
+        local_client = get_client(local_url)
+
+        console.print("[dim]Fetching cloud database state...[/dim]")
+        cloud_client = get_client(cloud_url)
+
+        # Compute diffs
+        differ = DatabaseDiff(local_client, cloud_client)
+
+        # Get schema diff
+        schema_diff = None
+        if show_all or schema:
+            schema_diff = differ.compute_schema_diff()
+
+        # Get data diff
+        data_diff = None
+        if show_all or data:
+            data_diff = differ.compute_data_diff()
+
+        # Get vectors diff
+        vectors_diff = None
+        if show_all or vectors:
+            vectors_diff = differ.compute_vectors_diff()
+
+        # Format and display output
+        formatter = DiffFormatter()
+
+        if json_output:
+            # JSON output
+            output = {
+                "schema": schema_diff,
+                "data": data_diff,
+                "vectors": vectors_diff
+            }
+            click.echo(json.dumps(output, indent=2))
+        else:
+            # Rich formatted output
+            if schema_diff:
+                formatter.format_schema_diff(schema_diff)
+
+            if data_diff:
+                formatter.format_data_diff(data_diff)
+
+            if vectors_diff:
+                formatter.format_vectors_diff(vectors_diff)
+
+            # Show summary
+            console.print("\n[dim]Use `ainative sync apply` to execute.[/dim]")
+
+    except click.ClickException:
+        raise
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {str(e)}")
+        if "--verbose" in click.get_current_context().args:
+            import traceback
+            console.print(traceback.format_exc())
+        raise click.Abort()

ainative/commands/tasks.py

@@ -0,0 +1,191 @@
+"""
+Task Execution CLI Commands
+
+Commands for task management (create, execute, status, list, sequence).
+"""
+
+import click
+import json
+from typing import Optional
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich import print as rprint
+
+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="task")
+def task_group():
+    """Manage agent tasks."""
+    pass
+
+
+@task_group.command(name="create")
+@click.option("--agent-id", required=True, help="Agent instance ID")
+@click.option("--type", "task_type", required=True, help="Task type")
+@click.option("--description", required=True, help="Task description")
+@click.option("--priority", default="medium", help="Task priority (low, medium, high, critical)")
+@click.option("--context", help="Task context as JSON string")
+def create_task(agent_id: str, task_type: str, description: str, priority: str, context: Optional[str]):
+    """Create a new task."""
+    try:
+        client = get_client()
+
+        context_data = {}
+        if context:
+            context_data = json.loads(context)
+
+        result = client.agent_orchestration.create_task(
+            agent_id=agent_id,
+            task_type=task_type,
+            description=description,
+            context=context_data,
+            priority=priority
+        )
+
+        console.print(Panel(
+            f"[green]✓[/green] Task created: {result.get('task_id')}",
+            title="Success"
+        ))
+        console.print(json.dumps(result, indent=2))
+
+    except Exception as e:
+        click.echo(f"Error: {str(e)}", err=True)
+
+
+@task_group.command(name="execute")
+@click.argument("task_id")
+@click.option("--agent-id", help="Optional specific agent to use")
+def execute_task(task_id: str, agent_id: Optional[str]):
+    """Execute a task."""
+    try:
+        client = get_client()
+        result = client.agent_orchestration.execute_task(task_id, agent_id=agent_id)
+
+        console.print(Panel(
+            f"[green]✓[/green] Task execution started",
+            title="Success"
+        ))
+        console.print(json.dumps(result, indent=2))
+
+    except Exception as e:
+        click.echo(f"Error: {str(e)}", err=True)
+
+
+@task_group.command(name="status")
+@click.argument("task_id")
+def get_status(task_id: str):
+    """Get task status."""
+    try:
+        client = get_client()
+        result = client.agent_orchestration.get_task_status(task_id)
+
+        status = result.get("status", "unknown")
+        status_color = {
+            "pending": "yellow",
+            "running": "blue",
+            "completed": "green",
+            "failed": "red"
+        }.get(status, "white")
+
+        console.print(Panel(
+            f"Status: [{status_color}]{status}[/{status_color}]\n\n" +
+            json.dumps(result, indent=2),
+            title=f"Task {task_id}"
+        ))
+
+    except Exception as e:
+        click.echo(f"Error: {str(e)}", err=True)
+
+
+@task_group.command(name="list")
+@click.option("--agent-id", help="Filter by agent ID")
+@click.option("--status", help="Filter by status")
+@click.option("--type", "task_type", help="Filter by task type")
+@click.option("--format", type=click.Choice(["table", "json"]), default="table",
+              help="Output format")
+def list_tasks(agent_id: Optional[str], status: Optional[str], task_type: Optional[str], format: str):
+    """List tasks."""
+    try:
+        client = get_client()
+        result = client.agent_orchestration.list_tasks(
+            agent_id=agent_id,
+            status=status,
+            task_type=task_type
+        )
+
+        tasks = result.get("tasks", [])
+
+        if format == "json":
+            click.echo(json.dumps(tasks, indent=2))
+        else:
+            table = Table(title="Tasks")
+            table.add_column("ID", style="cyan")
+            table.add_column("Type", style="bold")
+            table.add_column("Status", style="green")
+            table.add_column("Priority", justify="right")
+            table.add_column("Agent", style="dim")
+
+            for task in tasks:
+                table.add_row(
+                    task.get("id", "")[:12],
+                    task.get("task_type", ""),
+                    task.get("status", ""),
+                    task.get("priority", ""),
+                    task.get("agent_id", "")[:12]
+                )
+
+            console.print(table)
+            console.print(f"\nTotal: {len(tasks)} tasks")
+
+    except Exception as e:
+        click.echo(f"Error: {str(e)}", err=True)
+
+
+@task_group.command(name="sequence")
+@click.option("--name", required=True, help="Sequence name")
+@click.option("--tasks", required=True, help="Task IDs (comma-separated)")
+@click.option("--mode", default="sequential", help="Execution mode (sequential, parallel, conditional)")
+def create_sequence(name: str, tasks: str, mode: str):
+    """Create a task sequence."""
+    try:
+        client = get_client()
+
+        task_list = []
+        for task_id in tasks.split(","):
+            task_list.append({"task_id": task_id.strip()})
+
+        result = client.agent_coordination.create_task_sequence(
+            name=name,
+            tasks=task_list,
+            execution_mode=mode
+        )
+
+        console.print(Panel(
+            f"[green]✓[/green] Sequence created: {result.get('sequence_id')}",
+            title="Success"
+        ))
+        console.print(json.dumps(result, indent=2))
+
+    except Exception as e:
+        click.echo(f"Error: {str(e)}", err=True)

ainative/exceptions.py

@@ -0,0 +1,87 @@
+"""
+AINative SDK Exception Classes
+
+Custom exceptions for better error handling and debugging.
+"""
+
+from typing import Optional, Dict, Any
+
+
+class AINativeException(Exception):
+    """Base exception for all AINative SDK errors."""
+    
+    def __init__(
+        self,
+        message: str,
+        error_code: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+    ):
+        super().__init__(message)
+        self.message = message
+        self.error_code = error_code
+        self.details = details or {}
+
+
+class AuthenticationError(AINativeException):
+    """Raised when authentication fails."""
+    
+    def __init__(self, message: str = "Authentication failed"):
+        super().__init__(message, error_code="AUTH_ERROR")
+
+
+class APIError(AINativeException):
+    """Raised when API returns an error response."""
+    
+    def __init__(
+        self,
+        message: str,
+        status_code: Optional[int] = None,
+        response_body: Optional[str] = None,
+    ):
+        super().__init__(message, error_code="API_ERROR")
+        self.status_code = status_code
+        self.response_body = response_body
+
+
+class NetworkError(AINativeException):
+    """Raised when network-related errors occur."""
+    
+    def __init__(self, message: str = "Network error occurred"):
+        super().__init__(message, error_code="NETWORK_ERROR")
+
+
+class ValidationError(AINativeException):
+    """Raised when input validation fails."""
+    
+    def __init__(self, message: str, field: Optional[str] = None):
+        super().__init__(message, error_code="VALIDATION_ERROR")
+        self.field = field
+
+
+class RateLimitError(AINativeException):
+    """Raised when API rate limit is exceeded."""
+    
+    def __init__(
+        self,
+        message: str = "Rate limit exceeded",
+        retry_after: Optional[int] = None,
+    ):
+        super().__init__(message, error_code="RATE_LIMIT")
+        self.retry_after = retry_after
+
+
+class ResourceNotFoundError(AINativeException):
+    """Raised when requested resource is not found."""
+    
+    def __init__(self, resource_type: str, resource_id: str):
+        message = f"{resource_type} with ID {resource_id} not found"
+        super().__init__(message, error_code="NOT_FOUND")
+        self.resource_type = resource_type
+        self.resource_id = resource_id
+
+
+class TimeoutError(AINativeException):
+    """Raised when operation times out."""
+    
+    def __init__(self, message: str = "Operation timed out"):
+        super().__init__(message, error_code="TIMEOUT")

ainative/zerodb/__init__.py

@@ -0,0 +1,89 @@
+"""
+ZeroDB Module for AINative SDK
+
+Provides high-level interface for ZeroDB operations including projects,
+vectors, memory, and analytics.
+"""
+
+from typing import TYPE_CHECKING, List, Dict, Any, Optional
+from datetime import datetime
+
+if TYPE_CHECKING:
+    from ..client import AINativeClient
+
+from .projects import ProjectsClient
+from .vectors import VectorsClient
+from .memory import MemoryClient
+from .analytics import AnalyticsClient
+from .tables import TablesClient
+
+
+class ZeroDBClient:
+    """Main client for ZeroDB operations."""
+
+    def __init__(self, client: "AINativeClient"):
+        """
+        Initialize ZeroDB client.
+
+        Args:
+            client: Parent AINative client instance
+        """
+        self.client = client
+        self._projects: Optional[ProjectsClient] = None
+        self._vectors: Optional[VectorsClient] = None
+        self._memory: Optional[MemoryClient] = None
+        self._analytics: Optional[AnalyticsClient] = None
+        self._tables: Optional[TablesClient] = None
+
+    @property
+    def projects(self) -> ProjectsClient:
+        """Get projects operations client."""
+        if not self._projects:
+            self._projects = ProjectsClient(self.client)
+        return self._projects
+
+    @property
+    def vectors(self) -> VectorsClient:
+        """Get vectors operations client."""
+        if not self._vectors:
+            self._vectors = VectorsClient(self.client)
+        return self._vectors
+
+    @property
+    def memory(self) -> MemoryClient:
+        """Get memory operations client."""
+        if not self._memory:
+            self._memory = MemoryClient(self.client)
+        return self._memory
+
+    @property
+    def analytics(self) -> AnalyticsClient:
+        """Get analytics operations client."""
+        if not self._analytics:
+            self._analytics = AnalyticsClient(self.client)
+        return self._analytics
+
+    @property
+    def tables(self) -> TablesClient:
+        """Get NoSQL tables operations client."""
+        if not self._tables:
+            self._tables = TablesClient(self.client)
+        return self._tables
+    
+    def health_check(self) -> Dict[str, Any]:
+        """Check ZeroDB health status."""
+        return self.client.get("/zerodb/health")
+    
+    def get_usage_stats(self) -> Dict[str, Any]:
+        """Get usage statistics for ZeroDB."""
+        return self.client.get("/zerodb/usage")
+
+
+__all__ = [
+    "ZeroDBClient",
+    "ProjectsClient",
+    "VectorsClient",
+    "MemoryClient",
+    "AnalyticsClient",
+    "TablesClient",
+]