axon-protocol-cli 0.1.0__py3-none-any.whl

axon_cli/__init__.py

@@ -0,0 +1 @@
+# axon_cli package

axon_cli/commands/__init__.py

@@ -0,0 +1 @@
+# axon_cli/commands package

axon_cli/commands/agent.py

@@ -0,0 +1,105 @@
+import click
+from axon_cli.http import AxonHttpClient
+from axon_cli.config import save_config, load_config
+from axon_cli.display import print_success, print_info, print_table, print_panel
+
+@click.group()
+def agent():
+    """Manage agents and agent registration."""
+    pass
+
+@agent.command("register")
+@click.argument("name")
+@click.option("--project-id", help="Project ID for the agent (defaults to config Project ID)")
+@click.option("--org-id", help="Organization ID (optional)")
+@click.option("-c", "--capability", multiple=True, help="Capabilities of the agent (e.g. -c memory -c planning)")
+def register(name, project_id, org_id, capability):
+    """Register a new agent with the Axon server."""
+    config = load_config()
+    target_project = project_id or config.get("project_id")
+    if not target_project:
+        target_project = click.prompt("Project ID")
+
+    # Connect to client
+    client = AxonHttpClient()
+    
+    payload = {
+        "name": name,
+        "project_id": target_project,
+        "org_id": org_id,
+        "capabilities": list(capability) if capability else []
+    }
+    
+    print_info(f"Registering agent '{name}' in project '{target_project}'...")
+    res = client.post("/v1/agents/register", json=payload)
+    
+    # Save Project key, project_id, and agent info to local config
+    api_key_to_save = res.get("api_key") or client.api_key or ""
+    save_config(
+        base_url=client.base_url,
+        api_key=api_key_to_save,
+        project_id=target_project,
+        agent_id=res["id"],
+        agent_token=res["token"]
+    )
+    
+    # Display registration result
+    content = (
+        f"[bold]Agent ID:[/bold] {res['id']}\n"
+        f"[bold]Name:[/bold] {res['name']}\n"
+        f"[bold]Project ID:[/bold] {res['project_id']}\n"
+        f"[bold]API Key:[/bold] [yellow]{api_key_to_save}[/yellow] *(Saved to .axon)*\n"
+        f"[bold]JWT Token:[/bold] {res['token'][:30]}...\n"
+        f"[bold]Created At:[/bold] {res['created_at']}"
+    )
+    print_panel("Agent Registered", content, subtitle="Configuration Auto-Updated")
+    print_success(f"Successfully registered and authenticated agent '{name}'!")
+
+@agent.command("me")
+def me():
+    """Get details of the currently authenticated agent."""
+    client = AxonHttpClient()
+    if not client.api_key:
+        raise click.ClickException("No API key configured. Run 'axon init' or 'axon agent register'.")
+
+    print_info("Retrieving agent profile...")
+    res = client.get("/v1/agents/me")
+    
+    content = (
+        f"[bold]Agent ID:[/bold] {res['id']}\n"
+        f"[bold]Name:[/bold] {res['name']}\n"
+        f"[bold]Project ID:[/bold] {res['project_id']}\n"
+        f"[bold]Capabilities:[/bold] {', '.join(res.get('capabilities', [])) or 'None'}\n"
+        f"[bold]Status:[/bold] {res.get('status', 'unknown')}\n"
+        f"[bold]Last Seen:[/bold] {res.get('last_seen_at', 'never')}\n"
+        f"[bold]Created At:[/bold] {res['created_at']}"
+    )
+    print_panel("Agent Profile", content)
+
+@agent.command("list")
+def list_agents():
+    """List all agents registered in the current project."""
+    client = AxonHttpClient()
+    if not client.api_key:
+        raise click.ClickException("No API key configured. Run 'axon init' or 'axon agent register'.")
+
+    print_info(f"Listing agents for project '{client.project_id}'...")
+    res = client.get("/v1/agents/list")
+    agents = res.get("agents", [])
+    
+    if not agents:
+        print_info("No agents found in this project.")
+        return
+
+    headers = ["ID", "Name", "Capabilities", "Status", "Last Seen"]
+    rows = []
+    for a in agents:
+        rows.append([
+            a["id"],
+            a["name"],
+            ", ".join(a.get("capabilities", [])) or "None",
+            a.get("status", "unknown"),
+            a.get("last_seen_at") or "never"
+        ])
+    
+    print_table("Project Agents", headers, rows)

axon_cli/commands/init.py

@@ -0,0 +1,30 @@
+import click
+from axon_cli.config import save_config, load_config
+from axon_cli.display import print_success, print_info
+
+@click.command()
+@click.option("--base-url", default="http://localhost:8000", help="Axon server base URL (default: http://localhost:8000)")
+@click.option("--api-key", default="", help="Agent API key")
+@click.option("--project-id", default="", help="Project ID")
+@click.option("--interactive/--no-interactive", default=True, help="Prompt interactively if not provided via options")
+def init(base_url, api_key, project_id, interactive):
+    """Initialize a new .axon configuration file in the current directory."""
+    print_info("Initializing Axon Protocol CLI...")
+    
+    current_config = load_config()
+    
+    if interactive:
+        # Prompt for base URL
+        default_url = current_config.get("base_url") or base_url
+        base_url = click.prompt("Axon server base URL", default=default_url)
+        
+        # Prompt for api key
+        default_key = current_config.get("api_key") or api_key
+        api_key = click.prompt("Agent API key (optional)", default=default_key, show_default=True)
+        
+        # Prompt for project ID
+        default_project = current_config.get("project_id") or project_id
+        project_id = click.prompt("Project ID (optional)", default=default_project, show_default=True)
+
+    config_path = save_config(base_url, api_key, project_id)
+    print_success(f"Configuration saved successfully to {config_path}")

axon_cli/commands/lock.py

@@ -0,0 +1,115 @@
+import click
+from axon_cli.http import AxonHttpClient
+from axon_cli.display import print_success, print_info, print_error, print_table, print_panel
+
+@click.group()
+def lock():
+    """Manage distributed resource locks."""
+    pass
+
+@lock.command("list")
+def list_locks():
+    """List all active locks in the project."""
+    client = AxonHttpClient()
+    if not client.api_key:
+        raise click.ClickException("No API key configured. Run 'axon init' or 'axon agent register'.")
+
+    print_info("Listing active locks...")
+    res = client.get("/v1/lock/list")
+    locks = res.get("locks", [])
+    
+    if not locks:
+        print_info("No active locks found.")
+        return
+
+    headers = ["Resource ID", "Holder Agent ID", "Locked At", "Expires At"]
+    rows = []
+    for l in locks:
+        rows.append([
+            l["resource_id"],
+            l["agent_id"],
+            l["locked_at"][:19],
+            l["expires_at"][:19]
+        ])
+        
+    print_table("Active Locks", headers, rows)
+
+@lock.command("status")
+@click.argument("resource_id")
+def status(resource_id):
+    """Check the lock status of a resource."""
+    client = AxonHttpClient()
+    if not client.api_key:
+        raise click.ClickException("No API key configured. Run 'axon init' or 'axon agent register'.")
+
+    print_info(f"Checking lock status for resource '{resource_id}'...")
+    res = client.get(f"/v1/lock/status/{resource_id}")
+    
+    locked = res.get("locked", False)
+    if locked:
+        content = (
+            f"[bold]Status:[/bold] [red]LOCKED[/red]\n"
+            f"[bold]Resource ID:[/bold] {res['resource_id']}\n"
+            f"[bold]Holder Agent ID:[/bold] {res.get('holder_agent_id')}\n"
+            f"[bold]Locked At:[/bold] {res.get('locked_at')}\n"
+            f"[bold]Expires At:[/bold] {res.get('expires_at')}"
+        )
+        print_panel("Lock Status", content, border_style="red")
+    else:
+        content = (
+            f"[bold]Status:[/bold] [green]UNLOCKED[/green]\n"
+            f"[bold]Resource ID:[/bold] {res['resource_id']}"
+        )
+        print_panel("Lock Status", content, border_style="green")
+
+@lock.command("acquire")
+@click.argument("resource_id")
+@click.option("-t", "--timeout", type=int, default=300, help="Expiration timeout in seconds (default: 300)")
+@click.option("-m", "--metadata", multiple=True, help="Optional metadata (e.g. -m owner=daemon)")
+def acquire(resource_id, timeout, metadata):
+    """Acquire an exclusive lock on a resource."""
+    client = AxonHttpClient()
+    if not client.api_key:
+        raise click.ClickException("No API key configured. Run 'axon init' or 'axon agent register'.")
+
+    meta_dict = {}
+    for item in metadata:
+        if "=" in item:
+            k, v = item.split("=", 1)
+            meta_dict[k.strip()] = v.strip()
+        else:
+            meta_dict[item.strip()] = True
+
+    payload = {
+        "resource_id": resource_id,
+        "timeout": timeout,
+    }
+    if meta_dict:
+        payload["metadata"] = meta_dict
+
+    print_info(f"Acquiring lock on resource '{resource_id}'...")
+    res = client.post("/v1/lock/acquire", json=payload)
+    
+    content = (
+        f"[bold]Lock ID:[/bold] {res['lock_id']}\n"
+        f"[bold]Resource ID:[/bold] {res['resource_id']}\n"
+        f"[bold]Expires At:[/bold] {res['expires_at']}"
+    )
+    print_panel("Lock Acquired", content)
+    print_success(f"Successfully locked resource '{resource_id}'!")
+
+@lock.command("release")
+@click.argument("resource_id")
+def release(resource_id):
+    """Release a lock on a resource."""
+    client = AxonHttpClient()
+    if not client.api_key:
+        raise click.ClickException("No API key configured. Run 'axon init' or 'axon agent register'.")
+
+    print_info(f"Releasing lock on resource '{resource_id}'...")
+    res = client.post("/v1/lock/release", params={"resource_id": resource_id})
+    
+    if res.get("released"):
+        print_success(f"Lock on resource '{resource_id}' released successfully.")
+    else:
+        print_error(f"Failed to release lock on resource '{resource_id}'.")

axon_cli/commands/memory.py

@@ -0,0 +1,129 @@
+import click
+from axon_cli.http import AxonHttpClient
+from axon_cli.display import print_success, print_info, print_table, print_panel
+
+@click.group()
+def memory():
+    """Manage vector memory storage and retrieval."""
+    pass
+
+@memory.command("store")
+@click.argument("content")
+@click.option("-t", "--tag", multiple=True, help="Custom tags to attach to the memory (e.g. -t priority=high)")
+@click.option("-s", "--scope", default="project", help="Scope of the memory (e.g. project, agent) (default: project)")
+@click.option("--ttl", type=int, help="Time to live in seconds (optional)")
+def store(content, tag, scope, ttl):
+    """Store a memory in the Axon server."""
+    client = AxonHttpClient()
+    if not client.api_key:
+        raise click.ClickException("No API key configured. Run 'axon init' or 'axon agent register'.")
+
+    tags = {}
+    for item in tag:
+        if "=" in item:
+            k, v = item.split("=", 1)
+            tags[k.strip()] = v.strip()
+        else:
+            tags[item.strip()] = True
+
+    payload = {
+        "content": content,
+        "scope": scope,
+    }
+    if tags:
+        payload["tags"] = tags
+    if ttl is not None:
+        payload["ttl"] = ttl
+
+    print_info("Storing memory...")
+    res = client.post("/v1/memory/store", json=payload)
+    
+    print_success(f"Memory stored successfully!")
+    print_info(f"ID: {res['id']}")
+    print_info(f"Created At: {res['created_at']}")
+
+@memory.command("search")
+@click.argument("query")
+@click.option("-l", "--limit", type=int, default=10, help="Max number of results (default: 10)")
+@click.option("-m", "--min-similarity", type=float, default=0.5, help="Minimum cosine similarity threshold (default: 0.5)")
+@click.option("-s", "--scope", help="Search scope filter")
+def search(query, limit, min_similarity, scope):
+    """Semantically search stored memories."""
+    client = AxonHttpClient()
+    if not client.api_key:
+        raise click.ClickException("No API key configured. Run 'axon init' or 'axon agent register'.")
+
+    payload = {
+        "query": query,
+        "limit": limit,
+        "min_similarity": min_similarity,
+    }
+    if scope:
+        payload["scope"] = scope
+
+    print_info(f"Searching memories for '{query}'...")
+    res = client.post("/v1/memory/search", json=payload)
+    results = res.get("results", [])
+    
+    if not results:
+        print_info("No matching memories found.")
+        return
+
+    headers = ["Similarity", "Content", "Tags", "Scope", "Created At"]
+    rows = []
+    for r in results:
+        tags_str = ", ".join(f"{k}={v}" for k, v in r.get("tags", {}).items()) or "None"
+        rows.append([
+            f"{r['similarity']:.4f}",
+            r["content"],
+            tags_str,
+            r["scope"],
+            r["created_at"][:19]
+        ])
+        
+    print_table(f"Search Results for '{query}'", headers, rows)
+
+@memory.command("list")
+@click.option("-l", "--limit", type=int, default=50, help="Max number of results (default: 50)")
+def list_memories(limit):
+    """List recently stored memories in the current project."""
+    client = AxonHttpClient()
+    if not client.api_key:
+        raise click.ClickException("No API key configured. Run 'axon init' or 'axon agent register'.")
+
+    print_info("Listing memories...")
+    res = client.get("/v1/memory/list", params={"limit": limit})
+    memories = res.get("memories", [])
+    
+    if not memories:
+        print_info("No memories found.")
+        return
+
+    headers = ["ID", "Content", "Tags", "Scope", "Created At"]
+    rows = []
+    for m in memories:
+        tags_str = ", ".join(f"{k}={v}" for k, v in m.get("tags", {}).items()) or "None"
+        rows.append([
+            m["id"],
+            m["content"][:60] + ("..." if len(m["content"]) > 60 else ""),
+            tags_str,
+            m["scope"],
+            m["created_at"][:19]
+        ])
+        
+    print_table("Recent Memories", headers, rows)
+
+@memory.command("delete")
+@click.argument("memory_id")
+def delete(memory_id):
+    """Delete a memory permanently by its ID."""
+    client = AxonHttpClient()
+    if not client.api_key:
+        raise click.ClickException("No API key configured. Run 'axon init' or 'axon agent register'.")
+
+    print_info(f"Deleting memory {memory_id}...")
+    res = client.delete(f"/v1/memory/{memory_id}")
+    if res.get("deleted"):
+        print_success(f"Memory {memory_id} deleted successfully.")
+    else:
+        print_error(f"Failed to delete memory {memory_id}.")

axon_cli/commands/message.py

@@ -0,0 +1,100 @@
+import click
+import json
+from axon_cli.http import AxonHttpClient
+from axon_cli.display import print_success, print_info, print_error, print_table
+
+@click.group()
+def message():
+    """Manage agent-to-agent messaging."""
+    pass
+
+@message.command("send")
+@click.argument("recipient_id", required=False)
+@click.argument("text", required=False)
+@click.option("--topic", help="Topic to publish the message to")
+@click.option("--json", "json_payload", help="JSON string payload instead of plain text")
+def send(recipient_id, text, topic, json_payload):
+    """Send a message to an agent or publish to a topic."""
+    if not recipient_id and not topic:
+        raise click.ClickException("Must specify either recipient_id or --topic.")
+        
+    client = AxonHttpClient()
+    if not client.api_key:
+        raise click.ClickException("No API key configured. Run 'axon init'.")
+        
+    # Build payload
+    payload_dict = {}
+    if json_payload:
+        try:
+            payload_dict = json.loads(json_payload)
+        except json.JSONDecodeError as e:
+            raise click.ClickException(f"Invalid JSON payload: {str(e)}")
+    elif text:
+        payload_dict = {"text": text}
+    else:
+        payload_dict = {}
+
+    req_body = {}
+    if recipient_id:
+        req_body["recipient_id"] = recipient_id
+    if topic:
+        req_body["topic"] = topic
+    req_body["payload"] = payload_dict
+
+    print_info("Sending message...")
+    res = client.post("/v1/messages/send", json=req_body)
+    
+    print_success(f"Message sent successfully! ID: {res['message_id']}, Status: {res['status']}")
+
+@message.command("inbox")
+@click.option("--topic", help="Filter inbox by topic")
+@click.option("--limit", default=50, help="Limit the number of messages to fetch")
+def inbox(topic, limit):
+    """Fetch and view unread messages in the inbox."""
+    client = AxonHttpClient()
+    if not client.api_key:
+        raise click.ClickException("No API key configured. Run 'axon init'.")
+
+    params = {"limit": limit}
+    if topic:
+        params["topic"] = topic
+
+    print_info("Fetching messages from inbox...")
+    res = client.get("/v1/messages/inbox", params=params)
+    messages = res.get("messages", [])
+
+    if not messages:
+        print_info("Inbox is empty.")
+        return
+
+    headers = ["ID", "Sender ID", "Topic", "Payload", "Status", "Created At"]
+    rows = []
+    for m in messages:
+        payload_str = str(m.get("payload", {}))
+        if len(payload_str) > 40:
+            payload_str = payload_str[:37] + "..."
+        rows.append([
+            m["id"],
+            m["sender_id"],
+            m.get("topic") or "N/A",
+            payload_str,
+            m["status"],
+            m["created_at"]
+        ])
+
+    print_table("Agent Inbox", headers, rows)
+
+@message.command("ack")
+@click.argument("message_id")
+def ack(message_id):
+    """Acknowledge a received message."""
+    client = AxonHttpClient()
+    if not client.api_key:
+        raise click.ClickException("No API key configured. Run 'axon init'.")
+
+    print_info(f"Acknowledging message {message_id}...")
+    res = client.post("/v1/messages/ack", params={"message_id": message_id})
+    if res.get("acknowledged"):
+        print_success(f"Message {message_id} acknowledged successfully.")
+    else:
+        print_error(f"Failed to acknowledge message {message_id}.")

axon_cli/commands/receipt.py

@@ -0,0 +1,113 @@
+import click
+from axon_cli.http import AxonHttpClient
+from axon_cli.display import print_success, print_info, print_error, print_table, print_panel, console, supports_unicode
+
+@click.group()
+def receipt():
+    """Manage and verify reasoning receipts."""
+    pass
+
+@receipt.command("list")
+@click.option("-l", "--limit", type=int, default=50, help="Max number of receipts (default: 50)")
+def list_receipts(limit):
+    """List reasoning receipts."""
+    client = AxonHttpClient()
+    if not client.api_key:
+        raise click.ClickException("No API key configured. Run 'axon init' or 'axon agent register'.")
+
+    print_info("Listing receipts...")
+    res = client.get("/v1/receipts/list", params={"limit": limit})
+    receipts = res.get("receipts", [])
+    
+    if not receipts:
+        print_info("No receipts found.")
+        return
+
+    headers = ["ID", "Agent ID", "Input Sneak-peek", "Chain Hash", "Created At"]
+    rows = []
+    for r in receipts:
+        rows.append([
+            r["id"],
+            r["agent_id"],
+            r["input_text"],
+            r["chain_hash"][:16] + "...",
+            r["created_at"][:19]
+        ])
+        
+    print_table("Reasoning Receipts", headers, rows)
+
+@receipt.command("show")
+@click.argument("receipt_id")
+def show(receipt_id):
+    """Show details and reasoning chain of a receipt."""
+    client = AxonHttpClient()
+    if not client.api_key:
+        raise click.ClickException("No API key configured. Run 'axon init' or 'axon agent register'.")
+
+    print_info(f"Retrieving receipt {receipt_id}...")
+    res = client.get(f"/v1/receipts/{receipt_id}")
+    
+    # Metadata panel
+    metadata = (
+        f"[bold]Receipt ID:[/bold] {res['id']}\n"
+        f"[bold]Agent ID:[/bold] {res['agent_id']}\n"
+        f"[bold]Parent ID:[/bold] {res.get('parent_receipt_id') or 'None'}\n"
+        f"[bold]Chain Hash:[/bold] {res['chain_hash']}\n"
+        f"[bold]Signature:[/bold] {res['signature'][:40]}...\n"
+        f"[bold]Created At:[/bold] {res['created_at']}"
+    )
+    print_panel("Receipt Metadata", metadata)
+    
+    # Input/Output
+    console.print(f"\n[bold #818cf8]Input:[/bold #818cf8] {res['input_text']}\n")
+    
+    # Steps
+    console.print("[bold #818cf8]Reasoning Steps:[/bold #818cf8]")
+    steps = res.get("reasoning_steps", [])
+    if not steps:
+        console.print("  [dim]No steps recorded[/dim]")
+    else:
+        for idx, step in enumerate(steps, 1):
+            console.print(f"  [bold]{idx}. Thought:[/bold] {step.get('thought')}")
+            if step.get("tool_called"):
+                console.print(f"     [bold cyan]Tool:[/bold cyan] {step['tool_called']}")
+            if step.get("result"):
+                console.print(f"     [bold green]Result:[/bold green] {step['result']}")
+                
+    console.print(f"\n[bold #818cf8]Output:[/bold #818cf8] {res['output_text']}\n")
+
+@receipt.command("verify")
+@click.argument("receipt_id")
+def verify(receipt_id):
+    """Verify that a reasoning receipt has not been tampered with."""
+    client = AxonHttpClient()
+    if not client.api_key:
+        raise click.ClickException("No API key configured. Run 'axon init' or 'axon agent register'.")
+
+    print_info(f"Verifying receipt {receipt_id}...")
+    res = client.post("/v1/receipts/verify", params={"receipt_id": receipt_id})
+    
+    valid = res.get("valid", False)
+    check_icon = "✔" if supports_unicode() else "OK"
+    cross_icon = "✘" if supports_unicode() else "FAIL"
+    
+    if valid:
+        content = (
+            f"[bold]Receipt ID:[/bold] {res['receipt_id']}\n"
+            f"[bold]Status:[/bold] [green]VALID & UNTAMPERED[/green] (Integrity verified) {check_icon}\n"
+            f"[bold]Chain Hash:[/bold] {res['chain_hash']}\n"
+            f"[bold]Recomputed Hash:[/bold] {res['recomputed_hash']}\n"
+            f"[bold]Message:[/bold] {res['message']}"
+        )
+        print_panel("Verification Result", content, border_style="green")
+        print_success("Receipt integrity verified!")
+    else:
+        content = (
+            f"[bold]Receipt ID:[/bold] {res['receipt_id']}\n"
+            f"[bold]Status:[/bold] [red]INVALID / TAMPERED[/red] {cross_icon}\n"
+            f"[bold]Chain Hash:[/bold] {res['chain_hash']}\n"
+            f"[bold]Recomputed Hash:[/bold] {res['recomputed_hash']}\n"
+            f"[bold]Message:[/bold] {res['message']}"
+        )
+        print_panel("Verification Result", content, border_style="red")
+        print_error("WARNING: Receipt has been tampered with or is invalid!")

axon_cli/config.py

@@ -0,0 +1,71 @@
+import os
+import json
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+CONFIG_FILENAME = ".axon"
+
+def find_config_file() -> Optional[Path]:
+    """Search for .axon config file in the current directory."""
+    current = Path.cwd()
+    config_path = current / CONFIG_FILENAME
+    if config_path.is_file():
+        return config_path
+    return None
+
+def load_config() -> Dict[str, Any]:
+    """Load configuration from .axon file or environment variables."""
+    config = {
+        "base_url": os.getenv("AXON_BASE_URL", "http://localhost:8000"),
+        "api_key": os.getenv("AXON_API_KEY"),
+        "project_id": os.getenv("AXON_PROJECT_ID"),
+        "agent_id": os.getenv("AXON_AGENT_ID"),
+        "agent_token": os.getenv("AXON_AGENT_TOKEN"),
+    }
+
+    config_path = find_config_file()
+    if config_path:
+        try:
+            with open(config_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                if isinstance(data, dict):
+                    # Override defaults with config file values if present
+                    if "base_url" in data:
+                        config["base_url"] = data["base_url"]
+                    if "api_key" in data:
+                        config["api_key"] = data["api_key"]
+                    if "project_id" in data:
+                        config["project_id"] = data["project_id"]
+                    if "agent_id" in data:
+                        config["agent_id"] = data["agent_id"]
+                    if "agent_token" in data:
+                        config["agent_token"] = data["agent_token"]
+        except Exception:
+            # If JSON is corrupted or unreadable, fall back to environment/defaults
+            pass
+
+    return config
+
+def save_config(base_url: str, api_key: str, project_id: str, agent_id: str = None, agent_token: str = None) -> Path:
+    """Save configuration to .axon file in the current directory."""
+    config_path = Path.cwd() / CONFIG_FILENAME
+    
+    # Preserve existing agent values if not explicitly provided
+    existing = {}
+    if config_path.is_file():
+        try:
+            with open(config_path, "r", encoding="utf-8") as f:
+                existing = json.load(f)
+        except Exception:
+            pass
+            
+    data = {
+        "base_url": base_url,
+        "api_key": api_key,
+        "project_id": project_id,
+        "agent_id": agent_id or existing.get("agent_id"),
+        "agent_token": agent_token or existing.get("agent_token"),
+    }
+    with open(config_path, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2)
+    return config_path

axon_cli/display.py

@@ -0,0 +1,92 @@
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.text import Text
+from rich.json import JSON
+import json
+import sys
+from typing import List, Dict, Any
+
+console = Console()
+
+# Theme Colors
+ACCENT_COLOR = "purple"
+ACCENT_STYLE = "bold #818cf8"
+SUCCESS_STYLE = "bold green"
+ERROR_STYLE = "bold red"
+INFO_STYLE = "bold cyan"
+MUTED_STYLE = "dim white"
+
+def supports_unicode() -> bool:
+    """Check if the stdout stream supports Unicode/UTF-8 encoding."""
+    try:
+        encoding = getattr(sys.stdout, "encoding", None) or ""
+        return "utf" in encoding.lower()
+    except Exception:
+        return False
+
+def print_success(message: str):
+    prefix = "[bold green]✔[/bold green]" if supports_unicode() else "[bold green][OK][/bold green]"
+    console.print(f"{prefix} {message}")
+
+def print_error(message: str):
+    prefix = "[bold red]✘[/bold red]" if supports_unicode() else "[bold red][ERR][/bold red]"
+    console.print(f"{prefix} {message}")
+
+def print_info(message: str):
+    prefix = "[bold cyan]ℹ[/bold cyan]" if supports_unicode() else "[bold cyan][INFO][/bold cyan]"
+    console.print(f"{prefix} {message}")
+
+def print_logo():
+    # Use standard ASCII art to prevent encoding errors on cp1252
+    logo = r"""
+   [bold #6366f1]   _                  ___           _                  _ 
+  /_\  __  _____ _ _  | _ \_ _ ___ _| |_ ___  __ ___ | |
+ / _ \ \ \/ / _ \ ' \ |  _/ '_/ _ \  _| / _ \/ _/ _ \| |
+/_/ \_\/_/\_\___/_||_||_| |_| \___/\__|_\___/\__\___/|_|[/bold #6366f1]
+    """
+    console.print(logo)
+
+def print_table(title: str, headers: List[str], rows: List[List[str]]):
+    # Set safe border style if unicode not supported
+    border_style = "#3b82f6"
+    box_type = None if supports_unicode() else "ASCII"
+    
+    table = Table(
+        title=f"[bold #a855f7]{title}[/bold #a855f7]",
+        show_header=True,
+        header_style="bold #818cf8",
+        border_style=border_style
+    )
+    
+    # If unicode is not supported, rich uses ascii borders automatically if we tell it to.
+    # But Table doesn't have box_type parameter directly, instead we import Box from rich.box.
+    if not supports_unicode():
+        from rich.box import ASCII
+        table.box = ASCII
+
+    for header in headers:
+        table.add_column(header)
+    for row in rows:
+        table.add_row(*row)
+    console.print(table)
+
+def print_json_pretty(data: Any):
+    if isinstance(data, (dict, list)):
+        json_str = json.dumps(data)
+    else:
+        json_str = str(data)
+    console.print(JSON(json_str))
+
+def print_panel(title: str, content: str, subtitle: str = None, border_style: str = "#6366f1"):
+    panel = Panel(
+        content,
+        title=f"[bold #a855f7]{title}[/bold #a855f7]",
+        subtitle=subtitle,
+        border_style=border_style,
+        expand=False
+    )
+    if not supports_unicode():
+        from rich.box import ASCII
+        panel.box = ASCII
+    console.print(panel)

axon_cli/http.py

@@ -0,0 +1,76 @@
+import httpx
+import click
+from typing import Any, Dict, Optional
+from axon_cli.config import load_config
+
+class AxonHttpClient:
+    def __init__(self):
+        config = load_config()
+        self.base_url = config["base_url"].rstrip("/")
+        self.api_key = config["api_key"]
+        self.project_id = config["project_id"]
+        self.agent_id = config.get("agent_id")
+        self.agent_token = config.get("agent_token")
+
+        headers = {}
+        if self.api_key:
+            headers["X-API-Key"] = self.api_key
+        if self.agent_token:
+            headers["Authorization"] = f"Bearer {self.agent_token}"
+        if self.agent_id:
+            headers["X-Agent-ID"] = self.agent_id
+        
+        self.client = httpx.Client(
+            headers=headers,
+            timeout=10.0
+        )
+
+    def request(self, method: str, path: str, **kwargs) -> Any:
+        url = f"{self.base_url}{path}"
+        try:
+            response = self.client.request(method, url, **kwargs)
+        except httpx.ConnectError:
+            raise click.ClickException(
+                f"Cannot connect to Axon server at {self.base_url}.\n"
+                f"Make sure the server is running (e.g. uvicorn app.main:app)."
+            )
+        except httpx.TimeoutException:
+            raise click.ClickException(
+                f"Request to {url} timed out. Server may be overloaded."
+            )
+
+        if response.status_code == 200:
+            try:
+                return response.json()
+            except Exception:
+                return response.text
+
+        # Error handling
+        try:
+            detail = response.json().get("detail", response.text)
+        except Exception:
+            detail = response.text
+
+        if response.status_code == 401:
+            raise click.ClickException(f"Authentication failed (401): {detail}")
+        elif response.status_code == 403:
+            raise click.ClickException(f"Permission denied (403): {detail}")
+        elif response.status_code == 404:
+            raise click.ClickException(f"Not found (404): {detail}")
+        elif response.status_code == 409:
+            raise click.ClickException(f"Conflict (409): {detail}")
+        elif response.status_code == 429:
+            raise click.ClickException(f"Rate limited (429): Try again later.")
+        elif response.status_code >= 500:
+            raise click.ClickException(f"Server error ({response.status_code}): {detail}")
+        else:
+            raise click.ClickException(f"Unexpected status {response.status_code}: {detail}")
+
+    def get(self, path: str, params: Optional[Dict[str, Any]] = None) -> Any:
+        return self.request("GET", path, params=params)
+
+    def post(self, path: str, json: Optional[Dict[str, Any]] = None, params: Optional[Dict[str, Any]] = None) -> Any:
+        return self.request("POST", path, json=json, params=params)
+
+    def delete(self, path: str, params: Optional[Dict[str, Any]] = None) -> Any:
+        return self.request("DELETE", path, params=params)

axon_cli/main.py

@@ -0,0 +1,65 @@
+import click
+from axon_cli.commands.init import init
+from axon_cli.commands.agent import agent
+from axon_cli.commands.memory import memory
+from axon_cli.commands.lock import lock
+from axon_cli.commands.receipt import receipt
+from axon_cli.commands.message import message
+from axon_cli.http import AxonHttpClient
+from axon_cli.display import print_info, print_table, print_success, print_error, print_logo, supports_unicode
+
+@click.group()
+@click.version_option(version="0.1.0")
+def cli():
+    """Axon Protocol Command Line Interface.
+    
+    Interact with the Axon server directly from your terminal.
+    """
+    pass
+
+@cli.command()
+def doctor():
+    """Run diagnostics to verify backend services health."""
+    client = AxonHttpClient()
+    print_info("Running diagnostics on Axon Protocol backend...")
+    
+    # Call readiness check endpoint
+    try:
+        res = client.get("/v1/health/ready")
+    except Exception as e:
+        raise click.ClickException(f"Failed to connect to health endpoint: {str(e)}")
+        
+    status = res.get("status", "unknown")
+    checks = res.get("checks", {})
+    
+    headers = ["Service Component", "Status"]
+    rows = []
+    
+    check_icon = "✔" if supports_unicode() else "OK"
+    cross_icon = "✘" if supports_unicode() else "FAIL"
+    
+    for component, check_val in checks.items():
+        name = component.replace("_", " ").title()
+        if check_val == "ok":
+            status_str = f"[bold green]Healthy[/bold green] {check_icon}"
+        else:
+            status_str = f"[bold red]Degraded[/bold red] {cross_icon} ({check_val})"
+        rows.append([name, status_str])
+        
+    print_table("System Health Overview", headers, rows)
+    
+    if status == "ready":
+        print_success("All backend systems (Postgres, Redis, Embedder) are fully operational!")
+    else:
+        print_error("Axon Protocol system is degraded. Check component errors above.")
+
+# Register command groups
+cli.add_command(init)
+cli.add_command(agent)
+cli.add_command(memory)
+cli.add_command(lock)
+cli.add_command(receipt)
+cli.add_command(message)
+
+if __name__ == "__main__":
+    cli()

axon_protocol_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: axon-protocol-cli
+Version: 0.1.0
+Summary: CLI tool for Axon Protocol — interact with your Axon server from the terminal
+Author-email: Sarthak Dhatrak <sarthakmdhtr@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/axon-protocol/axon-cli
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.1.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: httpx>=0.27.0
+
+# Axon Protocol CLI (`axon-cli`)
+
+The official command-line interface for the **Axon Protocol** ecosystem. Monitor and manage agents, memory, locks, and receipts directly from your terminal.
+
+---
+
+## Installation
+
+Install `axon-cli` locally in editable mode:
+
+```bash
+cd e:\Axon\axon-cli
+pip install -e .
+```
+
+To install from production (once published):
+
+```bash
+pip install axon-cli
+```
+
+---
+
+## Command Reference
+
+### System Initialization & Health
+
+- **`axon init`**: Initialize or modify the `.axon` config file in the current directory.
+- **`axon doctor`**: Run quick readiness diagnostics on the database, Redis, and embedding model services.
+
+### Agent Management
+
+- **`axon agent register <name>`**: Register a new agent in a project. Automagically updates the local `.axon` config file with the newly generated API key.
+- **`axon agent me`**: Show current agent status, capabilities, and profile info.
+- **`axon agent list`**: List all agents registered in the active project.
+
+### Vector Memory
+
+- **`axon memory store "<content>"`**: Store a semantic memory.
+  - Option `-t, --tag key=value`: Attach custom metadata tags (can be passed multiple times).
+  - Option `-s, --scope <scope>`: Specify memory visibility scope (e.g. `agent` or `project`, defaults to `project`).
+  - Option `--ttl <seconds>`: Set time-to-live for the memory.
+- **`axon memory search "<query>"`**: Find semantically similar memories.
+  - Option `-l, --limit <n>`: Max results (default 10).
+  - Option `-m, --min-similarity <f>`: Similarity threshold (default 0.5).
+- **`axon memory list`**: List recent memories in the project.
+- **`axon memory delete <memory_id>`**: Delete a memory permanently.
+
+### Distributed Locking
+
+- **`axon lock list`**: List active locks in the project.
+- **`axon lock status <resource_id>`**: Get detailed status of a resource lock.
+- **`axon lock acquire <resource_id>`**: Acquire an exclusive lock on a resource.
+- **`axon lock release <resource_id>`**: Release a lock you hold.
+
+### Reasoning Receipts
+
+- **`axon receipt list`**: Browse recent receipts.
+- **`axon receipt show <receipt_id>`**: View complete details and reasoning chain for a receipt.
+- **`axon receipt verify <receipt_id>`**: Recompute and cryptographically verify a receipt's integrity.

axon_protocol_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+axon_cli/__init__.py,sha256=ops8sJsU7hi_YEveYB7EQ02Kxlj3Jik6oqjgh83BDcA,19
+axon_cli/config.py,sha256=5yZWFOWM8hZ52MMOejAY9L2YR1FDGuhLZrPUppV85eM,2615
+axon_cli/display.py,sha256=LLn2cAowanRmScQzXwYcqj6GdNUEttDWlw-XgHyl7c8,2959
+axon_cli/http.py,sha256=EGjxrydfQAGBJkj58Zv42zAPMSWwRj1tS1pHT3qpYoE,3010
+axon_cli/main.py,sha256=a8Pd1Tixesdo4OJBHHn5wtFn76ySPtNfiSyHD8Mcz2Y,2125
+axon_cli/commands/__init__.py,sha256=qKqrlX1X0BXMNCg8KOzYJEGowrcXQdskqTA60nR4_Ss,28
+axon_cli/commands/agent.py,sha256=qbLzozDjQqgskHNLuVaMtYIjBeh_5cp_khHG40ZxwUU,3873
+axon_cli/commands/init.py,sha256=S4mrveJdkxT5lcbWJqGghqgAuk2zJp1qJ2SrppSFM6w,1475
+axon_cli/commands/lock.py,sha256=YPnhpUTnnSV0YnBEZaTlxCHTAYEQBYS_jBFCd8j2tT8,4052
+axon_cli/commands/memory.py,sha256=UjFAr7Z2LkmvBv4aoSdG_XgjYrwMGre5J5zcgEG8NvE,4469
+axon_cli/commands/message.py,sha256=anVggDIPNePu04NfUy8Lpa2LIml3_fIhaZWFdPvF8CI,3337
+axon_cli/commands/receipt.py,sha256=pNrUX9xDd-8CujScXOOk6Rc-kVEAaTCn_RdYBVvTn3U,4510
+axon_protocol_cli-0.1.0.dist-info/METADATA,sha256=2p7-RwfzUIxwI_d51FF0NqBa9NRTA6Cmk5Qw0wTN-bo,2778
+axon_protocol_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+axon_protocol_cli-0.1.0.dist-info/entry_points.txt,sha256=sZblAaLp_fkhbY0xEKYAOAO8pPHFbCQduEzko7BY45I,43
+axon_protocol_cli-0.1.0.dist-info/top_level.txt,sha256=NQ_xhBs6IoiJbYBgrSVGsV6qAmLtQzVh81CyghR2tI0,9
+axon_protocol_cli-0.1.0.dist-info/RECORD,,

axon_protocol_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

axon_protocol_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+axon = axon_cli.main:cli

axon_protocol_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+axon_cli