arqera-cli 0.2.0__py3-none-any.whl

arqera_cli/__init__.py

@@ -0,0 +1,8 @@
+"""ARQERA CLI -- AI governance from your terminal."""
+
+from __future__ import annotations
+
+from arqera_cli.cli import main
+
+__all__ = ["main"]
+__version__ = "0.2.0"

arqera_cli/cli.py

@@ -0,0 +1,1341 @@
+#!/usr/bin/env python3
+"""
+ARQERA CLI -- command-line interface for the ARQERA platform.
+
+Usage:
+    arqera login                 Authenticate with your API key
+    arqera whoami                Check identity and connection
+    arqera chat [MESSAGE]        Chat with Ore (streaming, interactive)
+    arqera briefing              View today's briefing
+    arqera governance status     View governance health
+    arqera governance evaluate   Evaluate an action
+    arqera agents list           List available agents
+    arqera agents run ID         Run an agent
+    arqera evidence search       Search the evidence trail
+    arqera dimensions            View dimension scores
+    arqera init                  Initialize a new Arqera project
+    arqera deploy                Deploy a workflow manifest
+    arqera validate              Validate an agent manifest
+    arqera publish               Publish an agent to the marketplace
+    arqera mcp install           Install ARQERA MCP server for Claude
+
+Examples:
+    arqera login --api-key ak_live_abc123
+    arqera chat "What's my trust score?"
+    arqera briefing
+    arqera governance evaluate --action email.send --description "Send newsletter"
+    arqera evidence search --type governance_evaluation --limit 10
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import sys
+import time
+import urllib.request
+import webbrowser
+from pathlib import Path
+from urllib.error import HTTPError, URLError
+from typing import Any, Dict, Iterator, Optional
+
+
+# =============================================================================
+# CONFIGURATION
+# =============================================================================
+
+ARQERA_DIR = Path.home() / ".arqera"
+CREDENTIALS_FILE = ARQERA_DIR / "credentials.json"
+SWARM_KEY_FILE = ARQERA_DIR / "swarm-key"
+DEFAULT_BASE_URL = "https://api.arqera.io/api"
+MANIFEST_FILENAME = "arqera.yaml"
+
+TEMPLATES_DIR = Path(__file__).resolve().parent.parent / "templates"
+
+MANIFEST_TEMPLATE = """\
+# Arqera Project Manifest
+# Docs: https://docs.arqera.io/sdk/manifest
+
+version: "0.2"
+intent:
+  id: {project_name}.main
+  title: "{project_title}"
+  description: "{project_description}"
+  parameters: {{}}
+policy:
+  approvals_required: false
+  approval_level: "standard"
+  data_access:
+    - "read:protocol"
+    - "write:evidence"
+workflow:
+  id: "{project_name}.v1"
+  steps:
+    - id: execute
+      action:
+        type: execute
+        module: core
+        params: {{}}
+agent:
+  id: "{project_name}-agent"
+  name: "{project_title} Agent"
+  capabilities:
+    - "text-generation"
+context:
+  tenant_id: "{{{{ env.ARQERA_TENANT_ID }}}}"
+  user_id: "{{{{ env.ARQERA_USER_ID }}}}"
+  surface: "cli"
+"""
+
+
+# =============================================================================
+# HELPERS
+# =============================================================================
+
+def _api_request(
+    path: str,
+    method: str = "GET",
+    body: Optional[Dict[str, Any]] = None,
+    api_key: Optional[str] = None,
+    base_url: Optional[str] = None,
+    timeout: int = 30,
+) -> Any:
+    """Make an API request to the Arqera platform."""
+    url = f"{(base_url or DEFAULT_BASE_URL).rstrip('/')}{path}"
+    data = json.dumps(body).encode("utf-8") if body else None
+    req = urllib.request.Request(url, data=data, method=method)
+    req.add_header("Content-Type", "application/json")
+    req.add_header("Accept", "application/json")
+    req.add_header("User-Agent", "arqera-cli/0.2.0")
+
+    if api_key:
+        req.add_header("X-API-Key", api_key)
+
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            payload = resp.read().decode("utf-8")
+            return json.loads(payload) if payload else None
+    except HTTPError as exc:
+        body_text = exc.read().decode("utf-8") if exc.fp else ""
+        return {"error": True, "status": exc.code, "message": body_text}
+    except URLError as exc:
+        return {"error": True, "status": 0, "message": str(exc.reason)}
+
+
+def _stream_sse(
+    path: str,
+    body: Dict[str, Any],
+    api_key: str,
+    base_url: str,
+) -> Iterator[str]:
+    """Stream SSE response, yielding text chunks."""
+    try:
+        import httpx
+    except ImportError:
+        # Fall back to non-streaming if httpx not available
+        result = _api_request(path, method="POST", body=body, api_key=api_key, base_url=base_url)
+        if isinstance(result, dict):
+            content = (
+                result.get("response")
+                or result.get("message")
+                or result.get("content")
+                or result.get("reply")
+            )
+            if content:
+                yield content
+            else:
+                yield json.dumps(result, indent=2)
+        return
+
+    url = f"{base_url.rstrip('/')}{path}"
+    headers = {
+        "Content-Type": "application/json",
+        "Accept": "text/event-stream",
+        "X-API-Key": api_key,
+        "User-Agent": "arqera-cli/0.2.0",
+    }
+
+    with httpx.Client(timeout=60) as http:
+        with http.stream("POST", url, json=body, headers=headers) as response:
+            if response.status_code != 200:
+                error_body = response.read().decode("utf-8")
+                yield f"Error ({response.status_code}): {error_body}"
+                return
+
+            for line in response.iter_lines():
+                if not line:
+                    continue
+                if line.startswith("data: "):
+                    payload = line[6:]
+                    if payload == "[DONE]":
+                        return
+                    try:
+                        event = json.loads(payload)
+                        chunk = (
+                            event.get("chunk")
+                            or event.get("delta", {}).get("content")
+                            or event.get("content")
+                            or event.get("text")
+                            or ""
+                        )
+                        if chunk:
+                            yield chunk
+                    except json.JSONDecodeError:
+                        yield payload
+                else:
+                    try:
+                        data = json.loads(line)
+                        if data.get("type") == "chunk":
+                            yield data.get("chunk", "")
+                        elif data.get("type") == "error":
+                            yield f"\nError: {data.get('error', 'Unknown')}"
+                            return
+                    except json.JSONDecodeError:
+                        yield line
+
+
+def _load_credentials() -> Dict[str, Any]:
+    """Load stored credentials."""
+    if CREDENTIALS_FILE.exists():
+        return json.loads(CREDENTIALS_FILE.read_text())
+    return {}
+
+
+def _save_credentials(creds: Dict[str, Any]) -> None:
+    """Save credentials to disk."""
+    ARQERA_DIR.mkdir(parents=True, exist_ok=True)
+    CREDENTIALS_FILE.write_text(json.dumps(creds, indent=2))
+    CREDENTIALS_FILE.chmod(0o600)
+
+
+def _get_api_key() -> Optional[str]:
+    """Get API key from environment, credentials, or swarm key file."""
+    # Environment variable takes precedence
+    env_key = os.environ.get("ARQERA_API_KEY")
+    if env_key:
+        return env_key
+    creds = _load_credentials()
+    if creds.get("api_key"):
+        return creds["api_key"]
+    if SWARM_KEY_FILE.exists():
+        return SWARM_KEY_FILE.read_text().strip()
+    return None
+
+
+def _get_base_url() -> str:
+    """Get base URL from environment or credentials."""
+    env_url = os.environ.get("ARQERA_BASE_URL")
+    if env_url:
+        return env_url
+    creds = _load_credentials()
+    return creds.get("base_url", DEFAULT_BASE_URL)
+
+
+def _print_error(msg: str) -> None:
+    """Print an error message."""
+    print(f"\033[31mError:\033[0m {msg}", file=sys.stderr)
+
+
+def _print_success(msg: str) -> None:
+    """Print a success message."""
+    print(f"\033[32mOK:\033[0m {msg}")
+
+
+def _print_json(data: Any) -> None:
+    """Print formatted JSON."""
+    print(json.dumps(data, indent=2, default=str))
+
+
+def _require_auth() -> tuple[str, str]:
+    """Get API key and base URL, or exit with error."""
+    api_key = _get_api_key()
+    if not api_key:
+        _print_error("Not authenticated. Run 'arqera login' or set ARQERA_API_KEY.")
+        sys.exit(1)
+    return api_key, _get_base_url()
+
+
+# =============================================================================
+# COMMANDS
+# =============================================================================
+
+def cmd_init(args: argparse.Namespace) -> int:
+    """Initialize a new Arqera project."""
+    project_dir = Path(args.directory or ".").resolve()
+    project_name = args.name or project_dir.name
+    project_title = project_name.replace("-", " ").replace("_", " ").title()
+
+    if args.template:
+        template_file = TEMPLATES_DIR / f"intent-{args.template}.yaml"
+        if not template_file.exists():
+            _print_error(f"Template '{args.template}' not found.")
+            available = [f.stem.replace("intent-", "") for f in TEMPLATES_DIR.glob("intent-*.yaml")]
+            if available:
+                print(f"Available templates: {', '.join(available)}")
+            return 1
+        manifest_dest = project_dir / MANIFEST_FILENAME
+        project_dir.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(template_file, manifest_dest)
+        _print_success(f"Initialized from template '{args.template}' at {manifest_dest}")
+    else:
+        manifest_path = project_dir / MANIFEST_FILENAME
+        if manifest_path.exists() and not args.force:
+            _print_error(f"{MANIFEST_FILENAME} already exists. Use --force to overwrite.")
+            return 1
+
+        project_dir.mkdir(parents=True, exist_ok=True)
+        content = MANIFEST_TEMPLATE.format(
+            project_name=project_name,
+            project_title=project_title,
+            project_description=f"{project_title} powered by Arqera",
+        )
+        manifest_path.write_text(content)
+        _print_success(f"Initialized project at {project_dir}")
+
+    print(f"  Manifest: {MANIFEST_FILENAME}")
+    print(f"  Project:  {project_name}")
+    print()
+    print("Next steps:")
+    print("  1. Edit arqera.yaml to configure your workflow")
+    print("  2. Run 'arqera login' to authenticate")
+    print("  3. Run 'arqera deploy' to deploy your workflow")
+    return 0
+
+
+def cmd_login(args: argparse.Namespace) -> int:
+    """Authenticate via browser (device code flow) or API key."""
+    base_url = args.base_url or DEFAULT_BASE_URL
+
+    if args.api_key:
+        return _login_with_api_key(args.api_key, base_url)
+
+    return _login_with_device_code(base_url)
+
+
+def _login_with_api_key(api_key: str, base_url: str) -> int:
+    """Login with a provided API key."""
+    result = _api_request("/diagnostic/whoami", api_key=api_key, base_url=base_url)
+    if isinstance(result, dict) and result.get("error"):
+        _print_error(f"Authentication failed: {result.get('message', 'Unknown error')}")
+        return 1
+
+    _save_credentials({
+        "api_key": api_key,
+        "base_url": base_url,
+        "user": result.get("user") if isinstance(result, dict) else None,
+        "email": result.get("email") if isinstance(result, dict) else None,
+        "logged_in_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+    })
+
+    user_name = result.get("user", "unknown") if isinstance(result, dict) else "unknown"
+    _print_success(f"Logged in as {user_name}")
+    print(f"  Credentials saved to {CREDENTIALS_FILE}")
+    return 0
+
+
+def _login_with_device_code(base_url: str) -> int:
+    """Login via browser-based device code flow."""
+    result = _api_request("/auth/device/code", method="POST", body={}, base_url=base_url)
+    if isinstance(result, dict) and result.get("error"):
+        _print_error(f"Failed to start login: {result.get('message', 'Unknown error')}")
+        print("Tip: Use 'arqera login --api-key YOUR_KEY' for non-interactive login.")
+        return 1
+
+    device_code = result.get("device_code", "")
+    verification_url = result.get("verification_url", "")
+    expires_in = result.get("expires_in", 900)
+    interval = result.get("interval", 2)
+
+    print("Opening browser to authenticate...")
+    print(f"  If browser doesn't open, visit: {verification_url}")
+    print(f"  Your code: {device_code}")
+    print()
+
+    try:
+        webbrowser.open(verification_url)
+    except Exception:
+        pass
+
+    print("Waiting for authentication...", end="", flush=True)
+    deadline = time.time() + expires_in
+    while time.time() < deadline:
+        time.sleep(interval)
+        print(".", end="", flush=True)
+
+        poll_result = _api_request(
+            "/auth/device/token",
+            method="POST",
+            body={"device_code": device_code},
+            base_url=base_url,
+        )
+
+        if isinstance(poll_result, dict):
+            status = poll_result.get("status", "")
+            if status == "complete":
+                print()
+                api_key = poll_result.get("api_key") or poll_result.get("access_token")
+                if not api_key:
+                    _print_error("Authentication succeeded but no credentials returned.")
+                    return 1
+
+                whoami = _api_request("/diagnostic/whoami", api_key=api_key, base_url=base_url)
+                user_name = "unknown"
+                email = None
+                if isinstance(whoami, dict) and not whoami.get("error"):
+                    user_name = whoami.get("user", "unknown")
+                    email = whoami.get("email")
+
+                _save_credentials({
+                    "api_key": api_key,
+                    "base_url": base_url,
+                    "user": user_name,
+                    "email": email,
+                    "logged_in_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+                })
+
+                _print_success(f"Logged in as {email or user_name}")
+                print(f"  Credentials saved to {CREDENTIALS_FILE}")
+                return 0
+
+            elif status == "expired":
+                print()
+                _print_error("Device code expired. Please try again.")
+                return 1
+
+    print()
+    _print_error("Authentication timed out. Please try again.")
+    return 1
+
+
+def cmd_whoami(args: argparse.Namespace) -> int:
+    """Check identity and swarm connection."""
+    api_key, base_url = _require_auth()
+
+    result = _api_request("/diagnostic/whoami", api_key=api_key, base_url=base_url)
+
+    if isinstance(result, dict) and result.get("error"):
+        print("Not connected.")
+        _print_error(result.get("message", "Connection failed"))
+        return 1
+
+    if not isinstance(result, dict) or not result.get("connected"):
+        print("Not connected.")
+        return 1
+
+    is_admin = result.get("admin", False)
+    user_name = result.get("user", "unknown")
+
+    if is_admin:
+        print(f"Authenticated as {user_name} (admin).")
+    else:
+        print(f"Authenticated as {user_name}.")
+
+    if args.verbose:
+        print(f"  Email:   {result.get('email', 'N/A')}")
+        print(f"  Actor:   {result.get('actor_type', 'N/A')}")
+        print(f"  Admin:   {is_admin}")
+        print(f"  API:     {base_url}")
+
+    return 0
+
+
+def cmd_chat(args: argparse.Namespace) -> int:
+    """Chat with Ore from the terminal (streaming)."""
+    api_key, base_url = _require_auth()
+    session_id = f"cli-{int(time.time())}"
+
+    if args.message:
+        return _chat_send(args.message, session_id, api_key, base_url, stream=not args.no_stream)
+
+    # Interactive REPL mode
+    print("Ore chat (Ctrl+C to exit)")
+    print()
+    try:
+        while True:
+            try:
+                message = input("\033[36myou>\033[0m ").strip()
+            except EOFError:
+                print()
+                break
+            if not message:
+                continue
+            _chat_send(message, session_id, api_key, base_url, stream=not args.no_stream)
+            print()  # blank line between exchanges
+    except KeyboardInterrupt:
+        print()
+
+    return 0
+
+
+def _chat_send(
+    message: str,
+    session_id: str,
+    api_key: str,
+    base_url: str,
+    stream: bool = True,
+) -> int:
+    """Send a single chat message and print the response."""
+    if stream:
+        # Streaming mode -- tokens arrive in real time
+        print("\033[33more>\033[0m ", end="", flush=True)
+        body = {"message": message, "session_id": session_id, "stream": True}
+        got_content = False
+        for chunk in _stream_sse("/ara/chat", body, api_key, base_url):
+            print(chunk, end="", flush=True)
+            got_content = True
+        if got_content:
+            print()  # newline after stream
+        return 0
+
+    # Non-streaming fallback
+    result = _api_request(
+        "/ara/chat",
+        method="POST",
+        body={"message": message, "session_id": session_id},
+        api_key=api_key,
+        base_url=base_url,
+    )
+
+    if isinstance(result, dict) and result.get("error"):
+        _print_error(result.get("message", "Chat request failed"))
+        return 1
+
+    if isinstance(result, dict):
+        reply = (
+            result.get("response")
+            or result.get("message")
+            or result.get("reply")
+            or result.get("content")
+        )
+        if reply:
+            print(f"\033[33more>\033[0m {reply}")
+        else:
+            _print_json(result)
+    else:
+        print(result)
+
+    return 0
+
+
+def cmd_briefing(args: argparse.Namespace) -> int:
+    """View today's briefing."""
+    api_key, base_url = _require_auth()
+
+    result = _api_request(
+        "/page-data/home/briefing",
+        api_key=api_key,
+        base_url=base_url,
+    )
+
+    if isinstance(result, dict) and result.get("error"):
+        _print_error(f"Failed to fetch briefing: {result.get('message', 'Unknown error')}")
+        return 1
+
+    if not isinstance(result, dict):
+        print("No briefing data available.")
+        return 0
+
+    # Display greeting
+    greeting = result.get("greeting", "")
+    if greeting:
+        print(f"\033[1m{greeting}\033[0m")
+        print()
+
+    # Display sections
+    sections = result.get("sections", [])
+    for section in sections:
+        title = section.get("title", "")
+        summary = section.get("summary", "")
+        if title:
+            print(f"  \033[36m{title}\033[0m")
+        if summary:
+            print(f"  {summary}")
+        items = section.get("items", [])
+        for item in items:
+            if isinstance(item, str):
+                print(f"    - {item}")
+            elif isinstance(item, dict):
+                label = item.get("label", item.get("title", ""))
+                value = item.get("value", item.get("summary", ""))
+                if label:
+                    print(f"    - {label}: {value}")
+        print()
+
+    # Display energy
+    energy = result.get("energy", {})
+    if energy and isinstance(energy, dict):
+        level = energy.get("level", "")
+        label = energy.get("label", "")
+        if level or label:
+            print(f"  Energy: {label or level}")
+
+    # Display dimensions summary
+    dimensions = result.get("dimensions", [])
+    if dimensions:
+        print()
+        print("  \033[36mDimensions\033[0m")
+        for dim in dimensions:
+            name = dim.get("label", dim.get("name", dim.get("dimension", "")))
+            score = dim.get("score", 0)
+            trend = dim.get("trend", "")
+            trend_arrow = {"up": "^", "down": "v", "stable": "-"}.get(trend, "")
+            bar_len = int(score * 20)
+            bar = "#" * bar_len + "." * (20 - bar_len)
+            print(f"    {name:20s} [{bar}] {score:.0%} {trend_arrow}")
+
+    if args.json:
+        print()
+        _print_json(result)
+
+    return 0
+
+
+def cmd_governance_status(args: argparse.Namespace) -> int:
+    """View governance health status."""
+    api_key, base_url = _require_auth()
+
+    # Fetch trust score
+    trust_result = _api_request("/ara/trust/score", api_key=api_key, base_url=base_url)
+    # Fetch compliance status
+    compliance_result = _api_request("/compliance", api_key=api_key, base_url=base_url)
+
+    print("\033[1mGovernance Status\033[0m")
+    print()
+
+    # Trust score
+    if isinstance(trust_result, dict) and not trust_result.get("error"):
+        overall = trust_result.get("overall", 0)
+        print(f"  Trust Score: {overall:.0%}")
+        components = trust_result.get("components", {})
+        if components:
+            for name, value in components.items():
+                label = name.replace("_", " ").title()
+                print(f"    {label}: {value:.0%}")
+    else:
+        print("  Trust Score: unavailable")
+
+    print()
+
+    # Compliance
+    if isinstance(compliance_result, dict) and not compliance_result.get("error"):
+        print("  Compliance:")
+        frameworks = compliance_result.get("frameworks", [])
+        if frameworks:
+            for fw in frameworks:
+                fw_name = fw.get("name", fw.get("framework", ""))
+                fw_status = fw.get("status", "")
+                print(f"    {fw_name}: {fw_status}")
+        else:
+            status = compliance_result.get("status", "unknown")
+            print(f"    Status: {status}")
+    else:
+        print("  Compliance: unavailable")
+
+    if args.json:
+        print()
+        _print_json({"trust": trust_result, "compliance": compliance_result})
+
+    return 0
+
+
+def cmd_governance_evaluate(args: argparse.Namespace) -> int:
+    """Evaluate an action against governance laws."""
+    api_key, base_url = _require_auth()
+
+    body: Dict[str, Any] = {"action": args.action}
+    if args.description:
+        body["description"] = args.description
+    if args.context:
+        try:
+            body["context"] = json.loads(args.context)
+        except json.JSONDecodeError:
+            _print_error("Invalid JSON for --context")
+            return 1
+
+    result = _api_request(
+        "/ara/governance/evaluate",
+        method="POST",
+        body=body,
+        api_key=api_key,
+        base_url=base_url,
+    )
+
+    if isinstance(result, dict) and result.get("error"):
+        _print_error(f"Evaluation failed: {result.get('message', 'Unknown error')}")
+        return 1
+
+    if not isinstance(result, dict):
+        _print_json(result)
+        return 0
+
+    verdict = result.get("verdict", "unknown")
+    confidence = result.get("confidence", 0)
+    reasons = result.get("reasons", [])
+
+    # Colour the verdict
+    colour = {"proceed": "\033[32m", "review": "\033[33m", "deny": "\033[31m"}.get(
+        verdict, "\033[0m"
+    )
+
+    print(f"  Verdict:    {colour}{verdict}\033[0m")
+    print(f"  Confidence: {confidence:.0%}")
+    if reasons:
+        print("  Reasons:")
+        for reason in reasons:
+            print(f"    - {reason}")
+
+    laws = result.get("laws_evaluated", [])
+    if laws:
+        print(f"  Laws checked: {', '.join(laws)}")
+
+    if args.json:
+        print()
+        _print_json(result)
+
+    return 0
+
+
+def cmd_evidence_search(args: argparse.Namespace) -> int:
+    """Search the evidence trail."""
+    api_key, base_url = _require_auth()
+
+    params = f"?page=1&page_size={args.limit}"
+    if args.type:
+        params += f"&artifact_type={args.type}"
+    if args.start_date:
+        params += f"&start_date={args.start_date}"
+    if args.end_date:
+        params += f"&end_date={args.end_date}"
+
+    result = _api_request(
+        f"/ara/evidence{params}",
+        api_key=api_key,
+        base_url=base_url,
+    )
+
+    if isinstance(result, dict) and result.get("error"):
+        _print_error(f"Search failed: {result.get('message', 'Unknown error')}")
+        return 1
+
+    artifacts: list[Any] = []
+    if isinstance(result, list):
+        artifacts = result
+    elif isinstance(result, dict):
+        artifacts = result.get("items", result.get("artifacts", []))
+
+    if not artifacts:
+        print("No evidence artifacts found.")
+        return 0
+
+    print(f"  Found {len(artifacts)} artifact(s):")
+    print()
+    for artifact in artifacts:
+        art_id = artifact.get("id", "")
+        art_type = artifact.get("artifact_type", "")
+        created = artifact.get("created_at", "")
+        print(f"  [{created}] {art_type} (#{art_id})")
+        payload = artifact.get("payload", {})
+        if payload:
+            summary = json.dumps(payload, default=str)
+            if len(summary) > 120:
+                summary = summary[:117] + "..."
+            print(f"    {summary}")
+
+    return 0
+
+
+def cmd_dimensions(args: argparse.Namespace) -> int:
+    """View dimension scores."""
+    api_key, base_url = _require_auth()
+
+    result = _api_request("/briefing/dimensions", api_key=api_key, base_url=base_url)
+
+    if isinstance(result, dict) and result.get("error"):
+        _print_error(f"Failed to fetch dimensions: {result.get('message', 'Unknown error')}")
+        return 1
+
+    items: list[Any] = []
+    if isinstance(result, list):
+        items = result
+    elif isinstance(result, dict):
+        items = result.get("dimensions", result.get("items", []))
+
+    if not items:
+        print("No dimension data available.")
+        return 0
+
+    print("\033[1mLife Dimensions\033[0m")
+    print()
+
+    for dim in items:
+        name = dim.get("label", dim.get("name", dim.get("dimension", "")))
+        score = dim.get("score", 0)
+        trend = dim.get("trend", "stable")
+        conductance = dim.get("conductance", 0)
+        trend_arrow = {"up": "^", "down": "v", "stable": "-"}.get(trend, "")
+        bar_len = int(score * 20)
+        bar = "#" * bar_len + "." * (20 - bar_len)
+        print(f"  {name:20s} [{bar}] {score:.0%} {trend_arrow}  (c={conductance:.2f})")
+
+    if args.json:
+        print()
+        _print_json(result)
+
+    return 0
+
+
+def cmd_deploy(args: argparse.Namespace) -> int:
+    """Deploy a workflow manifest to the platform."""
+    manifest_path = Path(args.manifest or MANIFEST_FILENAME)
+    if not manifest_path.exists():
+        _print_error(f"Manifest not found: {manifest_path}")
+        print("Run 'arqera init' to create one.")
+        return 1
+
+    api_key, base_url = _require_auth()
+    manifest_content = manifest_path.read_text()
+
+    if args.dry_run:
+        print("[DRY RUN] Would deploy manifest:")
+        print(f"  File: {manifest_path}")
+        print(f"  API:  {base_url}")
+        print(f"  Size: {len(manifest_content)} bytes")
+        return 0
+
+    result = _api_request(
+        "/v1/protocol/manifest",
+        method="POST",
+        body={"manifest_yaml": manifest_content, "status": "active"},
+        api_key=api_key,
+        base_url=base_url,
+    )
+
+    if isinstance(result, dict) and result.get("error"):
+        _print_error(f"Deploy failed: {result.get('message', 'Unknown error')}")
+        return 1
+
+    _print_success("Workflow deployed successfully.")
+    if isinstance(result, dict):
+        if result.get("id"):
+            print(f"  Manifest ID: {result['id']}")
+        if result.get("version"):
+            print(f"  Version:     {result['version']}")
+    return 0
+
+
+def cmd_logs(args: argparse.Namespace) -> int:
+    """Stream execution logs."""
+    api_key, base_url = _require_auth()
+    params = f"?limit={args.limit}"
+    if args.workflow_id:
+        params += f"&workflow_id={args.workflow_id}"
+
+    result = _api_request(
+        f"/v1/protocol/executions{params}",
+        api_key=api_key,
+        base_url=base_url,
+    )
+
+    if isinstance(result, dict) and result.get("error"):
+        _print_error(f"Failed to fetch logs: {result.get('message', 'Unknown error')}")
+        return 1
+
+    entries = []
+    if isinstance(result, list):
+        entries = result
+    elif isinstance(result, dict) and result.get("items"):
+        entries = result["items"]
+
+    if entries:
+        for entry in entries:
+            ts = entry.get("created_at", "")
+            status = entry.get("status", "unknown")
+            wf_id = entry.get("workflow_id", "N/A")
+            print(f"[{ts}] {status:12s} {wf_id}")
+    else:
+        _print_json(result)
+
+    return 0
+
+
+def cmd_agents_list(args: argparse.Namespace) -> int:
+    """List available agents."""
+    api_key, base_url = _require_auth()
+    result = _api_request("/v1/agents", api_key=api_key, base_url=base_url)
+
+    if isinstance(result, dict) and result.get("error"):
+        _print_error(f"Failed to list agents: {result.get('message', 'Unknown error')}")
+        return 1
+
+    agents = result if isinstance(result, list) else (
+        result.get("items", []) if isinstance(result, dict) else []
+    )
+
+    if not agents:
+        print("No agents available.")
+        return 0
+
+    print(f"{'ID':<30s} {'Name':<25s} {'Status':<10s} {'Type':<15s}")
+    print("-" * 80)
+    for agent in agents:
+        agent_id = str(agent.get("id", "N/A"))
+        name = agent.get("name", "N/A")
+        status = agent.get("status", "N/A")
+        agent_type = agent.get("type", agent.get("role", "N/A"))
+        print(f"{agent_id:<30s} {name:<25s} {status:<10s} {agent_type:<15s}")
+
+    return 0
+
+
+def cmd_agents_run(args: argparse.Namespace) -> int:
+    """Run an agent."""
+    api_key, base_url = _require_auth()
+
+    body: Dict[str, Any] = {"agent_id": args.agent_id}
+    if args.input:
+        try:
+            body["input"] = json.loads(args.input)
+        except json.JSONDecodeError:
+            body["input"] = {"prompt": args.input}
+
+    if args.model:
+        body["model"] = args.model
+
+    result = _api_request(
+        "/v1/agents/run",
+        method="POST",
+        body=body,
+        api_key=api_key,
+        base_url=base_url,
+    )
+
+    if isinstance(result, dict) and result.get("error"):
+        _print_error(f"Agent execution failed: {result.get('message', 'Unknown error')}")
+        return 1
+
+    _print_json(result)
+    return 0
+
+
+def _load_manifest_file(manifest_path: Path) -> Optional[Dict[str, Any]]:
+    """Load and parse a YAML or JSON manifest file, returning dict or None on error."""
+    content = manifest_path.read_text()
+    # Try YAML first (requires pyyaml), fall back to JSON
+    try:
+        import yaml
+        return yaml.safe_load(content)
+    except ImportError:
+        pass
+    except Exception:
+        pass
+    try:
+        return json.loads(content)
+    except json.JSONDecodeError as exc:
+        _print_error(f"Failed to parse manifest: {exc}")
+        return None
+
+
+def _find_manifest_file(manifest_arg: Optional[str]) -> Optional[Path]:
+    """Find the manifest file. Checks explicit path, then arqera.yaml, then manifest.yaml."""
+    if manifest_arg:
+        p = Path(manifest_arg)
+        if p.exists():
+            return p
+        _print_error(f"Manifest not found: {p}")
+        return None
+    for name in ("arqera.yaml", "manifest.yaml"):
+        p = Path(name)
+        if p.exists():
+            return p
+    _print_error("No manifest file found. Expected arqera.yaml or manifest.yaml in current directory.")
+    return None
+
+
+def cmd_validate(args: argparse.Namespace) -> int:
+    """Validate an agent manifest against the AgentManifest v1 schema."""
+    manifest_path = _find_manifest_file(getattr(args, "manifest", None))
+    if not manifest_path:
+        return 1
+
+    manifest_data = _load_manifest_file(manifest_path)
+    if manifest_data is None:
+        return 1
+
+    api_key, base_url = _require_auth()
+
+    result = _api_request(
+        "/marketplace/manifest/validate",
+        method="POST",
+        body={"manifest": manifest_data},
+        api_key=api_key,
+        base_url=base_url,
+    )
+
+    if isinstance(result, dict) and result.get("error"):
+        _print_error(f"Validation request failed: {result.get('message', 'Unknown error')}")
+        return 1
+
+    if not isinstance(result, dict):
+        _print_error("Unexpected response from validation endpoint.")
+        return 1
+
+    if result.get("valid"):
+        _print_success(f"Manifest is valid ({manifest_path})")
+        if args.json:
+            _print_json(result.get("manifest", {}))
+        return 0
+
+    errors = result.get("errors", [])
+    _print_error(f"Manifest validation failed ({len(errors)} error(s)):")
+    for err in errors:
+        print(f"  - {err}")
+    return 1
+
+
+def cmd_publish(args: argparse.Namespace) -> int:
+    """Validate and publish an agent manifest to the marketplace."""
+    manifest_path = _find_manifest_file(getattr(args, "manifest", None))
+    if not manifest_path:
+        return 1
+
+    manifest_data = _load_manifest_file(manifest_path)
+    if manifest_data is None:
+        return 1
+
+    api_key, base_url = _require_auth()
+
+    # Step 1: Validate first
+    val_result = _api_request(
+        "/marketplace/manifest/validate",
+        method="POST",
+        body={"manifest": manifest_data},
+        api_key=api_key,
+        base_url=base_url,
+    )
+
+    if isinstance(val_result, dict) and not val_result.get("valid"):
+        errors = val_result.get("errors", [])
+        _print_error(f"Manifest validation failed ({len(errors)} error(s)):")
+        for err in errors:
+            print(f"  - {err}")
+        return 1
+
+    if isinstance(val_result, dict) and val_result.get("error"):
+        _print_error(f"Validation request failed: {val_result.get('message', 'Unknown error')}")
+        return 1
+
+    # Step 2: Publish to marketplace
+    listing_body: Dict[str, Any] = {
+        "name": manifest_data.get("name", "Unnamed Agent"),
+        "description": manifest_data.get("listing", {}).get("description", ""),
+        "type": manifest_data.get("slug", ""),
+        "category": manifest_data.get("category", "utilities"),
+        "manifest": manifest_data,
+    }
+
+    # Map pricing from manifest
+    pricing = manifest_data.get("pricing", {})
+    if pricing:
+        listing_body["price_type"] = pricing.get("type", "free")
+        listing_body["price_cents"] = pricing.get("cents", 0)
+
+    result = _api_request(
+        "/marketplace/listings",
+        method="POST",
+        body=listing_body,
+        api_key=api_key,
+        base_url=base_url,
+    )
+
+    if isinstance(result, dict) and result.get("error"):
+        _print_error(f"Publish failed: {result.get('message', 'Unknown error')}")
+        return 1
+
+    _print_success("Agent published to marketplace.")
+    if isinstance(result, dict):
+        if result.get("id"):
+            print(f"  Listing ID: {result['id']}")
+        if result.get("type"):
+            print(f"  Slug:       {result['type']}")
+        if result.get("status"):
+            print(f"  Status:     {result['status']}")
+    return 0
+
+
+def cmd_mcp_install(args: argparse.Namespace) -> int:
+    """Install ARQERA MCP server for Claude Code / Claude Desktop."""
+    api_key, base_url = _require_auth()
+
+    mcp_server_path = Path(__file__).resolve().parent.parent / "mcp" / "server.py"
+    if not mcp_server_path.exists():
+        _print_error(f"MCP server not found at {mcp_server_path}")
+        return 1
+
+    mcp_config = {
+        "command": sys.executable,
+        "args": [str(mcp_server_path)],
+        "env": {
+            "ARQERA_API_KEY": api_key,
+            "ARQERA_BASE_URL": base_url,
+        },
+    }
+
+    claude_config_path = Path.home() / ".claude" / "claude_desktop_config.json"
+    claude_config_path.parent.mkdir(parents=True, exist_ok=True)
+
+    config: Dict[str, Any] = {}
+    if claude_config_path.exists():
+        try:
+            config = json.loads(claude_config_path.read_text())
+        except json.JSONDecodeError:
+            config = {}
+
+    if "mcpServers" not in config:
+        config["mcpServers"] = {}
+
+    config["mcpServers"]["arqera"] = mcp_config
+    claude_config_path.write_text(json.dumps(config, indent=2))
+
+    _print_success("ARQERA MCP server installed for Claude Code")
+    print(f"  Config: {claude_config_path}")
+    print(f"  Server: {mcp_server_path}")
+    print()
+    print("Restart Claude Code to activate.")
+    return 0
+
+
+# =============================================================================
+# ARGUMENT PARSER
+# =============================================================================
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build the CLI argument parser."""
+    parser = argparse.ArgumentParser(
+        prog="arqera",
+        description="ARQERA CLI -- AI governance from your terminal",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""\
+Examples:
+  arqera login --api-key ak_live_abc123
+  arqera chat "What's my trust score?"
+  arqera chat                                   # interactive mode
+  arqera briefing
+  arqera governance status
+  arqera governance evaluate --action email.send
+  arqera dimensions
+  arqera evidence search --type governance_evaluation
+  arqera agents list
+  arqera validate                                  # validate arqera.yaml
+  arqera publish                                   # publish agent to marketplace
+
+Documentation: https://docs.arqera.io/sdk/cli
+""",
+    )
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # init
+    p_init = subparsers.add_parser(
+        "init", help="Initialize a new Arqera project",
+        description="Create an arqera.yaml manifest in the target directory.",
+    )
+    p_init.add_argument("directory", nargs="?", help="Project directory (default: current)")
+    p_init.add_argument("--name", "-n", help="Project name (default: directory name)")
+    p_init.add_argument(
+        "--template", "-t",
+        help="Use a template (e.g. support-triage, workflow-automation)",
+    )
+    p_init.add_argument("--force", "-f", action="store_true", help="Overwrite existing manifest")
+
+    # login
+    p_login = subparsers.add_parser(
+        "login", help="Authenticate and store credentials",
+        description="Log in with an API key or browser-based device code flow.",
+    )
+    p_login.add_argument("--api-key", "-k", help="API key (opens browser if not provided)")
+    p_login.add_argument("--base-url", help=f"API base URL (default: {DEFAULT_BASE_URL})")
+
+    # whoami
+    p_whoami = subparsers.add_parser(
+        "whoami", help="Check identity and connection",
+        description="Verify your authentication and display account details.",
+    )
+    p_whoami.add_argument("--verbose", "-v", action="store_true", help="Show detailed info")
+
+    # chat
+    p_chat = subparsers.add_parser(
+        "chat", help="Chat with Ore (streaming)",
+        description="Send messages to Ore. Tokens stream in real time.\n"
+                     "Omit the message for interactive REPL mode.",
+    )
+    p_chat.add_argument("message", nargs="?", default=None, help="Message (omit for interactive)")
+    p_chat.add_argument("--no-stream", action="store_true", help="Disable streaming")
+
+    # briefing
+    p_briefing = subparsers.add_parser(
+        "briefing", help="View today's briefing",
+        description="Display your personalised daily briefing with\n"
+                     "greeting, key sections, energy, and dimension scores.",
+    )
+    p_briefing.add_argument("--json", action="store_true", help="Output raw JSON")
+
+    # governance
+    p_governance = subparsers.add_parser("governance", help="Governance operations")
+    gov_sub = p_governance.add_subparsers(dest="governance_command", help="Governance commands")
+
+    p_gov_status = gov_sub.add_parser(
+        "status", help="View governance health",
+        description="Display trust score, compliance status, and governance metrics.",
+    )
+    p_gov_status.add_argument("--json", action="store_true", help="Output raw JSON")
+
+    p_gov_eval = gov_sub.add_parser(
+        "evaluate", help="Evaluate an action against governance laws",
+        description="Submit an action for governance evaluation and see the verdict.",
+    )
+    p_gov_eval.add_argument("--action", "-a", required=True, help="Action identifier (e.g. email.send)")
+    p_gov_eval.add_argument("--description", "-d", help="Human-readable description")
+    p_gov_eval.add_argument("--context", "-c", help="Additional context as JSON string")
+    p_gov_eval.add_argument("--json", action="store_true", help="Output raw JSON")
+
+    # evidence
+    p_evidence = subparsers.add_parser("evidence", help="Evidence trail operations")
+    evidence_sub = p_evidence.add_subparsers(dest="evidence_command", help="Evidence commands")
+
+    p_ev_search = evidence_sub.add_parser(
+        "search", help="Search the evidence trail",
+        description="Search evidence artifacts with optional filters.",
+    )
+    p_ev_search.add_argument("--type", "-t", help="Filter by artifact type")
+    p_ev_search.add_argument("--start-date", help="Start date (ISO format)")
+    p_ev_search.add_argument("--end-date", help="End date (ISO format)")
+    p_ev_search.add_argument("--limit", "-l", type=int, default=20, help="Max results (default: 20)")
+
+    # dimensions
+    p_dimensions = subparsers.add_parser(
+        "dimensions", help="View dimension scores",
+        description="Display scores for all life dimensions with trends\n"
+                     "and Physarum conductance values.",
+    )
+    p_dimensions.add_argument("--json", action="store_true", help="Output raw JSON")
+
+    # agents
+    p_agents = subparsers.add_parser("agents", help="Manage agents")
+    agents_sub = p_agents.add_subparsers(dest="agents_command", help="Agent commands")
+
+    agents_sub.add_parser("list", help="List available agents")
+
+    p_agents_run = agents_sub.add_parser("run", help="Run an agent")
+    p_agents_run.add_argument("agent_id", help="Agent ID to execute")
+    p_agents_run.add_argument("--input", "-i", help="Input JSON or text prompt")
+    p_agents_run.add_argument("--model", help="Model override")
+
+    # validate
+    p_validate = subparsers.add_parser(
+        "validate", help="Validate an agent manifest",
+        description="Validate arqera.yaml or manifest.yaml against the AgentManifest v1 schema.",
+    )
+    p_validate.add_argument("--manifest", "-m", help="Manifest file (default: arqera.yaml)")
+    p_validate.add_argument("--json", action="store_true", help="Output validated manifest as JSON")
+
+    # publish
+    p_publish = subparsers.add_parser(
+        "publish", help="Publish an agent to the marketplace",
+        description="Validate and submit an agent manifest as a marketplace listing.",
+    )
+    p_publish.add_argument("--manifest", "-m", help="Manifest file (default: arqera.yaml)")
+
+    # deploy
+    p_deploy = subparsers.add_parser("deploy", help="Deploy a workflow manifest")
+    p_deploy.add_argument("--manifest", "-m", help=f"Manifest file (default: {MANIFEST_FILENAME})")
+    p_deploy.add_argument("--dry-run", action="store_true", help="Preview without deploying")
+
+    # logs
+    p_logs = subparsers.add_parser("logs", help="Stream execution logs")
+    p_logs.add_argument("--workflow-id", "-w", help="Filter by workflow ID")
+    p_logs.add_argument("--limit", "-l", type=int, default=20, help="Number of entries (default: 20)")
+
+    # mcp
+    p_mcp = subparsers.add_parser("mcp", help="MCP server management")
+    mcp_sub = p_mcp.add_subparsers(dest="mcp_command", help="MCP commands")
+    mcp_sub.add_parser("install", help="Install ARQERA MCP server for Claude Code")
+
+    return parser
+
+
+# =============================================================================
+# MAIN
+# =============================================================================
+
+def main() -> int:
+    """CLI entry point."""
+    parser = build_parser()
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        return 0
+
+    # Top-level commands
+    top_commands = {
+        "init": cmd_init,
+        "login": cmd_login,
+        "whoami": cmd_whoami,
+        "chat": cmd_chat,
+        "briefing": cmd_briefing,
+        "validate": cmd_validate,
+        "publish": cmd_publish,
+        "deploy": cmd_deploy,
+        "logs": cmd_logs,
+        "dimensions": cmd_dimensions,
+    }
+
+    if args.command in top_commands:
+        return top_commands[args.command](args)
+
+    # Nested commands
+    if args.command == "governance":
+        if not getattr(args, "governance_command", None):
+            parser.parse_args(["governance", "--help"])
+            return 0
+        gov_commands = {
+            "status": cmd_governance_status,
+            "evaluate": cmd_governance_evaluate,
+        }
+        return gov_commands[args.governance_command](args)
+
+    if args.command == "evidence":
+        if not getattr(args, "evidence_command", None):
+            parser.parse_args(["evidence", "--help"])
+            return 0
+        ev_commands = {
+            "search": cmd_evidence_search,
+        }
+        return ev_commands[args.evidence_command](args)
+
+    if args.command == "mcp":
+        if not getattr(args, "mcp_command", None):
+            parser.parse_args(["mcp", "--help"])
+            return 0
+        mcp_commands = {
+            "install": cmd_mcp_install,
+        }
+        return mcp_commands[args.mcp_command](args)
+
+    if args.command == "agents":
+        if not getattr(args, "agents_command", None):
+            parser.parse_args(["agents", "--help"])
+            return 0
+        agent_commands = {
+            "list": cmd_agents_list,
+            "run": cmd_agents_run,
+        }
+        return agent_commands[args.agents_command](args)
+
+    parser.print_help()
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

arqera_cli-0.2.0.dist-info/METADATA

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: arqera-cli
+Version: 0.2.0
+Summary: ARQERA CLI -- AI governance from your terminal
+Project-URL: Homepage, https://arqera.io
+Project-URL: Repository, https://github.com/Arqera-IO/ARQERA
+Project-URL: Documentation, https://docs.arqera.io/sdk/cli
+Author-email: ARQERA <engineering@arqera.io>
+License-Expression: Apache-2.0
+Keywords: ai,arqera,cli,compliance,evidence,governance
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.9
+Provides-Extra: streaming
+Requires-Dist: httpx>=0.25.0; extra == 'streaming'

arqera_cli-0.2.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+arqera_cli/__init__.py,sha256=q_5jq8UEgp0a9kgqetDF8l56HptFRs1-lTxyTOq4KGM,165
+arqera_cli/cli.py,sha256=UVi99gueRsyyel4IQoSTseGZabPAnK7dsubd23lfXug,45229
+arqera_cli-0.2.0.dist-info/METADATA,sha256=aKnTjbJhll8VklOw6w_l4GlE6_-RNfoWw5x3Qj3oO4Y,1123
+arqera_cli-0.2.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+arqera_cli-0.2.0.dist-info/entry_points.txt,sha256=VR5C1jBjZSbmPs3FAih0v2z06y-24ufOhE21TqEqXoI,47
+arqera_cli-0.2.0.dist-info/RECORD,,

arqera_cli-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

arqera_cli-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+arqera = arqera_cli.cli:main