daita-cli 0.1.0__py3-none-any.whl

daita_cli/__init__.py

@@ -0,0 +1,5 @@
+try:
+    import importlib.metadata
+    __version__ = importlib.metadata.version("daita-cli")
+except Exception:
+    __version__ = "0.1.0"

daita_cli/api_client.py

@@ -0,0 +1,103 @@
+"""
+DaitaAPIClient — async httpx client shared by CLI commands and MCP server.
+"""
+
+import os
+import httpx
+from typing import Any
+
+from daita_cli import __version__
+
+_DEFAULT_BASE_URL = "https://api.daita-tech.io"
+
+
+class APIError(Exception):
+    def __init__(self, status_code: int, detail: str, raw: Any = None):
+        super().__init__(detail)
+        self.status_code = status_code
+        self.detail = detail
+        self.raw = raw
+
+
+class AuthError(APIError): ...
+class NotFoundError(APIError): ...
+class ValidationError(APIError): ...
+class RateLimitError(APIError): ...
+class ServerError(APIError): ...
+
+
+def _raise_for(status: int, detail: str, raw: Any) -> None:
+    if status in (401, 403):
+        raise AuthError(status, detail, raw)
+    if status == 404:
+        raise NotFoundError(status, detail, raw)
+    if status in (400, 422):
+        raise ValidationError(status, detail, raw)
+    if status == 429:
+        raise RateLimitError(status, detail, raw)
+    if status >= 500:
+        raise ServerError(status, detail, raw)
+    raise APIError(status, detail, raw)
+
+
+class DaitaAPIClient:
+    def __init__(self, api_key: str = None, base_url: str = None):
+        self.api_key = api_key or os.getenv("DAITA_API_KEY")
+        self.base_url = (base_url or os.getenv("DAITA_API_ENDPOINT") or _DEFAULT_BASE_URL).rstrip("/")
+        self._client: httpx.AsyncClient | None = None
+
+    def _headers(self) -> dict:
+        if not self.api_key:
+            raise AuthError(401, "DAITA_API_KEY is not set. Export it or pass --api-key.")
+        return {
+            "Authorization": f"Bearer {self.api_key}",
+            "User-Agent": f"Daita-CLI/{__version__}",
+            "Content-Type": "application/json",
+        }
+
+    async def __aenter__(self) -> "DaitaAPIClient":
+        self._client = httpx.AsyncClient(base_url=self.base_url, timeout=30.0)
+        return self
+
+    async def __aexit__(self, *_) -> None:
+        if self._client:
+            await self._client.aclose()
+            self._client = None
+
+    def _check_client(self) -> httpx.AsyncClient:
+        if self._client is None:
+            raise RuntimeError("DaitaAPIClient must be used as an async context manager")
+        return self._client
+
+    async def _handle(self, resp: httpx.Response) -> Any:
+        if resp.is_success:
+            try:
+                return resp.json()
+            except Exception:
+                return resp.text
+        try:
+            body = resp.json()
+            detail = body.get("detail") or body.get("message") or str(body)
+        except Exception:
+            detail = resp.text or f"HTTP {resp.status_code}"
+        _raise_for(resp.status_code, detail, resp)
+
+    async def get(self, path: str, params: dict = None) -> Any:
+        resp = await self._check_client().get(path, headers=self._headers(), params=params)
+        return await self._handle(resp)
+
+    async def post(self, path: str, json: dict = None) -> Any:
+        resp = await self._check_client().post(path, headers=self._headers(), json=json)
+        return await self._handle(resp)
+
+    async def put(self, path: str, json: dict = None) -> Any:
+        resp = await self._check_client().put(path, headers=self._headers(), json=json)
+        return await self._handle(resp)
+
+    async def patch(self, path: str, json: dict = None) -> Any:
+        resp = await self._check_client().patch(path, headers=self._headers(), json=json)
+        return await self._handle(resp)
+
+    async def delete(self, path: str, params: dict = None) -> Any:
+        resp = await self._check_client().delete(path, headers=self._headers(), params=params)
+        return await self._handle(resp)

daita_cli/command_helpers.py

@@ -0,0 +1,58 @@
+"""
+@api_command decorator — wraps async Click commands with client injection,
+OutputFormatter injection, and standardised error/exit-code handling.
+
+Usage:
+    @cli.command()
+    @click.argument("name")
+    @api_command
+    async def my_cmd(client, formatter, name): ...
+"""
+
+import asyncio
+import functools
+import sys
+
+import click
+
+from daita_cli.api_client import AuthError, NotFoundError, APIError, DaitaAPIClient
+from daita_cli.output import OutputFormatter
+
+
+def api_command(f):
+    """
+    Decorator that:
+    1. Runs the coroutine via asyncio.run()
+    2. Injects `client` (DaitaAPIClient) and `formatter` (OutputFormatter) as first two args
+    3. Maps exceptions to exit codes: 0=ok, 1=error, 2=auth, 130=interrupt
+    """
+    @functools.wraps(f)
+    @click.pass_context
+    def wrapper(ctx, *args, **kwargs):
+        obj = ctx.obj or {}
+        formatter: OutputFormatter = obj.get("formatter", OutputFormatter())
+
+        async def _run():
+            async with DaitaAPIClient() as client:
+                return await f(client, formatter, *args, **kwargs)
+
+        try:
+            asyncio.run(_run())
+        except AuthError as e:
+            formatter.error("AUTH_ERROR", str(e))
+            sys.exit(2)
+        except NotFoundError as e:
+            formatter.error("NOT_FOUND", str(e))
+            sys.exit(1)
+        except APIError as e:
+            formatter.error("API_ERROR", str(e), {"status_code": e.status_code})
+            sys.exit(1)
+        except KeyboardInterrupt:
+            sys.exit(130)
+        except click.ClickException:
+            raise
+        except Exception as e:
+            formatter.error("ERROR", str(e))
+            sys.exit(1)
+
+    return wrapper

daita_cli/commands/agents.py

@@ -0,0 +1,52 @@
+import click
+from daita_cli.command_helpers import api_command
+
+
+@click.group()
+def agents():
+    """Manage agents."""
+    pass
+
+
+@agents.command("list")
+@click.option("--type", "agent_type", type=click.Choice(["agent", "workflow"]), help="Filter by type")
+@click.option("--status", type=click.Choice(["active", "inactive"]), help="Filter by status")
+@click.option("--page", default=1, show_default=True, help="Page number")
+@click.option("--per-page", default=20, show_default=True, help="Items per page")
+@api_command
+async def list_agents(client, formatter, agent_type, status, page, per_page):
+    """List agents."""
+    params = {"page": page, "per_page": per_page}
+    if agent_type:
+        params["agent_type"] = agent_type
+    if status:
+        params["status_filter"] = status
+    data = await client.get("/api/v1/agents/agents", params=params)
+    items = data if isinstance(data, list) else data.get("agents", data.get("items", []))
+    formatter.list_items(
+        items,
+        columns=["id", "name", "type", "status", "created_at"],
+        title="Agents",
+    )
+
+
+@agents.command("show")
+@click.argument("agent_id")
+@api_command
+async def show_agent(client, formatter, agent_id):
+    """Show agent details."""
+    data = await client.get(f"/api/v1/agents/agents/{agent_id}")
+    formatter.item(data)
+
+
+@agents.command("deployed")
+@api_command
+async def deployed_agents(client, formatter):
+    """List deployed agents with configuration."""
+    data = await client.get("/api/v1/agents/agents/deployed")
+    items = data if isinstance(data, list) else data.get("agents", data.get("items", []))
+    formatter.list_items(
+        items,
+        columns=["id", "name", "type", "status", "deployed_at"],
+        title="Deployed Agents",
+    )

daita_cli/commands/conversations.py

@@ -0,0 +1,75 @@
+"""
+Conversations — requires user_id for all requests.
+The backend scopes conversations per user. From the CLI, user_id defaults to "cli"
+(all CLI-created conversations share this scope). Override with --user-id.
+"""
+
+import click
+from daita_cli.command_helpers import api_command
+
+_USER_ID_OPT = click.option(
+    "--user-id", default="cli", show_default=True,
+    help="User ID for scoping conversations (default: 'cli')",
+)
+
+
+@click.group()
+def conversations():
+    """Manage conversations."""
+    pass
+
+
+@conversations.command("list")
+@_USER_ID_OPT
+@click.option("--agent-name")
+@click.option("--limit", default=20, show_default=True)
+@api_command
+async def list_conversations(client, formatter, user_id, agent_name, limit):
+    """List conversations."""
+    params = {"user_id": user_id, "limit": limit}
+    if agent_name:
+        params["agent_name"] = agent_name
+    data = await client.get("/api/v1/conversations", params=params)
+    items = data if isinstance(data, list) else data.get("conversations", data.get("items", []))
+    formatter.list_items(
+        items,
+        columns=["id", "title", "agent_name", "created_at"],
+        title="Conversations",
+    )
+
+
+@conversations.command("show")
+@click.argument("conversation_id")
+@_USER_ID_OPT
+@api_command
+async def show_conversation(client, formatter, conversation_id, user_id):
+    """Show conversation details."""
+    data = await client.get(f"/api/v1/conversations/{conversation_id}", params={"user_id": user_id})
+    formatter.item(data)
+
+
+@conversations.command("create")
+@click.option("--agent-name", required=True)
+@click.option("--title")
+@_USER_ID_OPT
+@api_command
+async def create_conversation(client, formatter, agent_name, title, user_id):
+    """Create a new conversation."""
+    payload = {"agent_name": agent_name, "user_id": user_id}
+    if title:
+        payload["title"] = title
+    data = await client.post("/api/v1/conversations", json=payload)
+    formatter.success(data, message=f"Conversation created: {data.get('id', '')}")
+
+
+@conversations.command("delete")
+@click.argument("conversation_id")
+@_USER_ID_OPT
+@api_command
+async def delete_conversation(client, formatter, conversation_id, user_id):
+    """Delete a conversation."""
+    data = await client.delete(
+        f"/api/v1/conversations/{conversation_id}",
+        params={"user_id": user_id},
+    )
+    formatter.success(data, message=f"Conversation {conversation_id} deleted.")

daita_cli/commands/create.py

@@ -0,0 +1,182 @@
+"""
+daita create agent|workflow <name> — add a component to the current project.
+No daita-agents dependency required.
+"""
+
+import sys
+from datetime import datetime
+from pathlib import Path
+
+import click
+import yaml
+
+from daita_cli.output import OutputFormatter
+from daita_cli.project_utils import ensure_project_root
+
+
+@click.group("create")
+def create_group():
+    """Create agents, workflows, and other components."""
+    pass
+
+
+@create_group.command("agent")
+@click.argument("name")
+@click.pass_context
+def create_agent(ctx, name):
+    """Create a new agent."""
+    obj = ctx.obj or {}
+    formatter = obj.get("formatter", OutputFormatter())
+    try:
+        _create_component("agent", name, formatter)
+    except click.ClickException:
+        raise
+    except Exception as e:
+        formatter.error("ERROR", str(e))
+        sys.exit(1)
+
+
+@create_group.command("workflow")
+@click.argument("name")
+@click.pass_context
+def create_workflow(ctx, name):
+    """Create a new workflow."""
+    obj = ctx.obj or {}
+    formatter = obj.get("formatter", OutputFormatter())
+    try:
+        _create_component("workflow", name, formatter)
+    except click.ClickException:
+        raise
+    except Exception as e:
+        formatter.error("ERROR", str(e))
+        sys.exit(1)
+
+
+def _to_class_name(name: str) -> str:
+    return "".join(w.capitalize() for w in name.replace("-", "_").split("_") if w)
+
+
+def _clean_name(name: str) -> str:
+    return name.replace("-", "_").lower()
+
+
+def _create_component(template: str, name: str, formatter: OutputFormatter):
+    project_root = ensure_project_root()
+    clean_name = _clean_name(name)
+    class_name = _to_class_name(clean_name)
+
+    if template == "agent":
+        dest_dir = project_root / "agents"
+        dest_file = dest_dir / f"{clean_name}.py"
+        if dest_file.exists():
+            raise click.ClickException(f"Agent '{clean_name}' already exists.")
+        dest_dir.mkdir(exist_ok=True)
+        dest_file.write_text(_agent_template(clean_name, class_name))
+    elif template == "workflow":
+        dest_dir = project_root / "workflows"
+        dest_file = dest_dir / f"{clean_name}.py"
+        if dest_file.exists():
+            raise click.ClickException(f"Workflow '{clean_name}' already exists.")
+        dest_dir.mkdir(exist_ok=True)
+        dest_file.write_text(_workflow_template(clean_name, class_name))
+    else:
+        raise click.ClickException(f"Unknown template: {template}")
+
+    # Prompt for display name (non-interactive: use default)
+    default_display = clean_name.replace("_", " ").title()
+    if sys.stdin.isatty():
+        display_name = click.prompt(
+            f"  Display name for deployment",
+            default=default_display,
+        )
+    else:
+        display_name = default_display
+
+    _update_config(project_root, template + "s", clean_name, display_name)
+
+    formatter.success(
+        {"name": clean_name, "display_name": display_name, "file": str(dest_file)},
+        message=f"  Created {template}: {clean_name}  (display: '{display_name}')",
+    )
+
+
+def _update_config(project_root: Path, component_key: str, name: str, display_name: str):
+    cfg_file = project_root / "daita-project.yaml"
+    if cfg_file.exists():
+        with open(cfg_file) as f:
+            config = yaml.safe_load(f) or {}
+    else:
+        config = {}
+
+    config.setdefault(component_key, [])
+    if not any(c["name"] == name for c in config[component_key]):
+        config[component_key].append({
+            "name": name,
+            "display_name": display_name,
+            "type": "standard" if component_key == "agents" else "basic",
+            "created_at": datetime.now().isoformat(),
+        })
+        with open(cfg_file, "w") as f:
+            yaml.dump(config, f, default_flow_style=False)
+
+
+def _agent_template(name: str, class_name: str) -> str:
+    return f'''\
+"""
+{class_name} Agent
+"""
+from daita import Agent
+
+
+def create_agent():
+    """Create the agent instance."""
+    return Agent(
+        name="{class_name}",
+        model="gpt-4o-mini",
+        prompt="You are a helpful AI assistant.",
+    )
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    async def main():
+        agent = create_agent()
+        await agent.start()
+        try:
+            answer = await agent.run("Hello!")
+            print(answer)
+        finally:
+            await agent.stop()
+
+    asyncio.run(main())
+'''
+
+
+def _workflow_template(name: str, class_name: str) -> str:
+    return f'''\
+"""
+{class_name} Workflow
+"""
+from daita import Agent, Workflow
+
+
+def create_workflow():
+    """Create the workflow instance."""
+    workflow = Workflow("{class_name}")
+    agent = Agent(name="Agent", model="gpt-4o-mini", prompt="You are helpful.")
+    workflow.add_agent("agent", agent)
+    return workflow
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    async def main():
+        wf = create_workflow()
+        await wf.start()
+        await wf.stop()
+        print("Done")
+
+    asyncio.run(main())
+'''

daita_cli/commands/deployments.py

@@ -0,0 +1,73 @@
+import click
+from daita_cli.command_helpers import api_command
+
+
+@click.group()
+def deployments():
+    """Manage deployments."""
+    pass
+
+
+@deployments.command("list")
+@click.option("--limit", default=10, show_default=True)
+@api_command
+async def list_deployments(client, formatter, limit):
+    """List deployments."""
+    data = await client.get("/api/v1/deployments/api-key", params={"per_page": limit})
+    items = data if isinstance(data, list) else data.get("deployments", data.get("items", []))
+    formatter.list_items(
+        items,
+        columns=["deployment_id", "project_name", "environment", "status", "version", "deployed_at"],
+        title="Deployments",
+    )
+
+
+@deployments.command("show")
+@click.argument("deployment_id")
+@api_command
+async def show_deployment(client, formatter, deployment_id):
+    """Show deployment details."""
+    data = await client.get(f"/api/v1/deployments/{deployment_id}")
+    formatter.item(data)
+
+
+@deployments.command("delete")
+@click.argument("deployment_id")
+@click.option("--force", is_flag=True, help="Skip confirmation")
+@api_command
+async def delete_deployment(client, formatter, deployment_id, force):
+    """Delete a deployment."""
+    if not force:
+        click.confirm(f"Delete deployment {deployment_id}?", abort=True)
+    data = await client.delete(f"/api/v1/deployments/{deployment_id}")
+    formatter.success(data, message=f"Deployment {deployment_id} deleted.")
+
+
+@deployments.command("history")
+@click.argument("project_name")
+@click.option("--limit", default=10, show_default=True)
+@api_command
+async def deployment_history(client, formatter, project_name, limit):
+    """Show deployment history for a project."""
+    data = await client.get(
+        f"/api/v1/deployments/history/{project_name}",
+        params={"per_page": limit},
+    )
+    items = data if isinstance(data, list) else data.get("deployments", data.get("items", []))
+    formatter.list_items(
+        items,
+        columns=["deployment_id", "environment", "status", "version", "deployed_at"],
+        title=f"Deployment History: {project_name}",
+    )
+
+
+@deployments.command("rollback")
+@click.argument("deployment_id")
+@click.option("--force", is_flag=True, help="Skip confirmation")
+@api_command
+async def rollback_deployment(client, formatter, deployment_id, force):
+    """Rollback to a previous deployment."""
+    if not force:
+        click.confirm(f"Rollback to deployment {deployment_id}?", abort=True)
+    data = await client.post(f"/api/v1/deployments/rollback/{deployment_id}")
+    formatter.success(data, message=f"Rolled back to deployment {deployment_id}.")

daita_cli/commands/executions.py

@@ -0,0 +1,76 @@
+import click
+from daita_cli.command_helpers import api_command
+
+
+@click.group(invoke_without_command=True)
+@click.option("--limit", default=10, show_default=True)
+@click.option("--status", type=click.Choice(["queued", "running", "completed", "failed", "cancelled"]))
+@click.option("--type", "target_type", type=click.Choice(["agent", "workflow"]))
+@click.pass_context
+def executions(ctx, limit, status, target_type):
+    """Manage executions."""
+    if ctx.invoked_subcommand is None:
+        # Backward compat: `daita executions` with no subcommand → list
+        ctx.invoke(list_executions, limit=limit, status=status, target_type=target_type)
+
+
+@executions.command("list")
+@click.option("--limit", default=10, show_default=True)
+@click.option("--status", type=click.Choice(["queued", "running", "completed", "failed", "cancelled"]))
+@click.option("--type", "target_type", type=click.Choice(["agent", "workflow"]))
+@api_command
+async def list_executions(client, formatter, limit, status, target_type):
+    """List executions."""
+    params = {"limit": limit}
+    if status:
+        params["status"] = status
+    if target_type:
+        params["target_type"] = target_type
+    data = await client.get("/api/v1/autonomous/executions", params=params)
+    items = data if isinstance(data, list) else data.get("executions", data.get("items", []))
+    formatter.list_items(
+        items,
+        columns=["execution_id", "target_name", "target_type", "status", "created_at", "duration_ms"],
+        title="Executions",
+    )
+
+
+@executions.command("show")
+@click.argument("execution_id")
+@api_command
+async def show_execution(client, formatter, execution_id):
+    """Show execution details."""
+    data = await client.get(f"/api/v1/autonomous/executions/{execution_id}")
+    formatter.item(data)
+
+
+@executions.command("logs")
+@click.argument("execution_id")
+@click.option("--follow", "-f", is_flag=True, help="Poll until complete")
+@api_command
+async def execution_logs(client, formatter, execution_id, follow):
+    """Show logs for an execution."""
+    import asyncio
+    import sys
+
+    if follow:
+        while True:
+            data = await client.get(f"/api/v1/autonomous/executions/{execution_id}")
+            formatter.item(data, fields=["execution_id", "status", "created_at", "duration_ms", "error"])
+            if data.get("status") in ("completed", "success", "failed", "error", "cancelled"):
+                break
+            if not formatter.is_json:
+                print("  polling...")
+            await asyncio.sleep(2)
+    else:
+        data = await client.get(f"/api/v1/autonomous/executions/{execution_id}")
+        formatter.item(data)
+
+
+@executions.command("cancel")
+@click.argument("execution_id")
+@api_command
+async def cancel_execution(client, formatter, execution_id):
+    """Cancel a running execution."""
+    data = await client.delete(f"/api/v1/autonomous/executions/{execution_id}")
+    formatter.success(data, message=f"Execution {execution_id} cancelled.")