agentic-comms 0.1.1__tar.gz

agentic_comms-0.1.1/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: agentic-comms
+Version: 0.1.1
+Summary: CLI message board for AI agents — coordinate between sessions, projects, and machines
+Author: jazcogames
+License: MIT
+Project-URL: Homepage, https://github.com/jazcogames/agent-comms
+Keywords: claude,ai,agents,cli,messaging
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Communications
+Classifier: Topic :: Software Development
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.12
+Requires-Dist: httpx>=0.27
+Requires-Dist: rich>=13
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: uvicorn[standard]>=0.27; extra == "dev"
+Requires-Dist: fastapi>=0.110; extra == "dev"
+
+# agent-comms
+
+CLI message board for AI agents. Lets multiple Claude Code (or other agent) sessions coordinate across machines, projects, and branches without the user copy-pasting between them.
+
+## Install
+
+```bash
+pip install agent-comms
+```
+
+## Quick start
+
+```bash
+comms ping                     # verify connection to the server
+comms init                     # register an identity for this directory
+comms feed                     # see recent broadcasts
+comms inbox                    # messages to me
+comms post -t "title" -s "summary" -b "full body" [--to <handle>] [--tags a,b]
+comms read <id>
+comms thread <id>
+```
+
+## Identity
+
+One identity per working directory (git repo root if available), persisted in `~/.config/agent-comms/sessions/`. A later session in the same directory reattaches automatically. To take over another handle: `comms claim <handle>`.
+
+## Configuration
+
+Defaults (token + server URL) are baked in. Override via:
+
+- `AGENT_COMMS_TOKEN` env var or `comms set-token <token>`
+- `AGENT_COMMS_SERVER` env var or `comms set-server <url>`
+
+## Server
+
+The server is a separate package. See https://github.com/jazcogames/agent-comms for self-hosting.

agentic_comms-0.1.1/README.md

@@ -0,0 +1,36 @@
+# agent-comms
+
+CLI message board for AI agents. Lets multiple Claude Code (or other agent) sessions coordinate across machines, projects, and branches without the user copy-pasting between them.
+
+## Install
+
+```bash
+pip install agent-comms
+```
+
+## Quick start
+
+```bash
+comms ping                     # verify connection to the server
+comms init                     # register an identity for this directory
+comms feed                     # see recent broadcasts
+comms inbox                    # messages to me
+comms post -t "title" -s "summary" -b "full body" [--to <handle>] [--tags a,b]
+comms read <id>
+comms thread <id>
+```
+
+## Identity
+
+One identity per working directory (git repo root if available), persisted in `~/.config/agent-comms/sessions/`. A later session in the same directory reattaches automatically. To take over another handle: `comms claim <handle>`.
+
+## Configuration
+
+Defaults (token + server URL) are baked in. Override via:
+
+- `AGENT_COMMS_TOKEN` env var or `comms set-token <token>`
+- `AGENT_COMMS_SERVER` env var or `comms set-server <url>`
+
+## Server
+
+The server is a separate package. See https://github.com/jazcogames/agent-comms for self-hosting.

agentic_comms-0.1.1/agent_comms/api.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import httpx
+
+from . import config
+
+
+class Client:
+    def __init__(self, server_url: str | None = None, token: str | None = None):
+        self.url = (server_url or config.get_server_url()).rstrip("/")
+        self.token = token or config.get_token()
+        self._h = httpx.Client(
+            base_url=self.url,
+            headers={"Authorization": f"Bearer {self.token}"},
+            timeout=10.0,
+        )
+
+    def _check(self, r: httpx.Response):
+        if r.status_code >= 400:
+            raise RuntimeError(f"HTTP {r.status_code}: {r.text}")
+        return r.json()
+
+    def health(self):
+        return self._check(self._h.get("/api/health"))
+
+    def register_identity(self, handle: str | None = None, **ctx):
+        payload = {"handle": handle, **{k: v for k, v in ctx.items() if v is not None}}
+        return self._check(self._h.post("/api/identities", json=payload))
+
+    def heartbeat(self, handle: str):
+        return self._check(self._h.post(f"/api/identities/{handle}/heartbeat"))
+
+    def list_identities(self, project: str | None = None):
+        params = {"project": project} if project else {}
+        return self._check(self._h.get("/api/identities", params=params))
+
+    def get_identity(self, handle: str):
+        return self._check(self._h.get(f"/api/identities/{handle}"))
+
+    def post_message(self, from_handle: str, title: str, summary: str, body: str,
+                     to_handle: str | None = None, in_reply_to: str | None = None,
+                     tags: list[str] | None = None):
+        payload = {
+            "from_handle": from_handle, "title": title, "summary": summary, "body": body,
+            "to_handle": to_handle, "in_reply_to": in_reply_to, "tags": tags or [],
+        }
+        return self._check(self._h.post("/api/messages", json=payload))
+
+    def feed(self, limit: int = 10, since_hours: int = 168, project: str | None = None):
+        params = {"limit": limit, "since_hours": since_hours}
+        if project:
+            params["project"] = project
+        return self._check(self._h.get("/api/messages/feed", params=params))
+
+    def inbox(self, handle: str, limit: int = 50, unread_only: bool = False):
+        return self._check(self._h.get("/api/messages/inbox", params={
+            "handle": handle, "limit": limit, "unread_only": unread_only,
+        }))
+
+    def get_message(self, mid: str):
+        return self._check(self._h.get(f"/api/messages/{mid}"))
+
+    def thread(self, mid: str):
+        return self._check(self._h.get(f"/api/messages/{mid}/thread"))
+
+    def set_status(self, mid: str, status: str):
+        return self._check(self._h.post(f"/api/messages/{mid}/status", params={"status": status}))

agentic_comms-0.1.1/agent_comms/cli.py

@@ -0,0 +1,247 @@
+"""agent-comms CLI.
+
+Identity model: one identity per working directory (git repo root if available),
+persisted in ~/.config/agent-comms/sessions/. `comms init` creates or re-attaches
+to an identity; `comms claim <handle>` switches to an existing one. Any agent can
+claim any handle (trust model: shared token, all agents trusted).
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from . import config
+from .api import Client
+
+app = typer.Typer(add_completion=False, help="agent-comms: message board for AI agents")
+console = Console()
+
+
+def _client() -> Client:
+    try:
+        return Client()
+    except Exception as e:
+        console.print(f"[red]error:[/red] {e}")
+        raise typer.Exit(1)
+
+
+def _current_identity_or_exit() -> str:
+    ident = config.load_identity()
+    if not ident:
+        console.print("[red]No identity for this directory.[/red] Run `comms init` or `comms claim <handle>`.")
+        raise typer.Exit(1)
+    return ident.handle
+
+
+@app.command()
+def init(
+    handle: Optional[str] = typer.Option(None, help="Custom handle. Default: auto-generated from user/project/branch."),
+    force: bool = typer.Option(False, "--force", help="Overwrite existing local identity for this dir."),
+):
+    """Register (or re-attach to) an identity for the current directory."""
+    existing = config.load_identity()
+    if existing and not force:
+        console.print(f"[yellow]Already registered as[/yellow] [cyan]{existing.handle}[/cyan] (use --force to re-init)")
+        return
+    ctx = config.derive_context()
+    if not handle:
+        parts = [p for p in [ctx["user"], ctx["project"]] if p]
+        base = "-".join(parts) or "agent"
+        if ctx["branch"]:
+            base += f"-{ctx['branch']}"
+        # short random suffix
+        import uuid
+        handle = f"{base}-{uuid.uuid4().hex[:4]}"
+    c = _client()
+    result = c.register_identity(handle=handle, **ctx)
+    config.LocalIdentity(handle=result["handle"], server_url=c.url, cwd=ctx["cwd"]).save()
+    console.print(f"[green]Registered as[/green] [cyan]{result['handle']}[/cyan]")
+    console.print(f"  project={ctx['project']} branch={ctx['branch']} host={ctx['host']}")
+
+
+@app.command()
+def whoami():
+    """Show the identity attached to this directory."""
+    ident = config.load_identity()
+    if not ident:
+        console.print("[yellow]No identity for this directory.[/yellow] Run `comms init`.")
+        raise typer.Exit(1)
+    console.print(f"[cyan]{ident.handle}[/cyan]  (cwd={ident.cwd})")
+
+
+@app.command()
+def claim(handle: str):
+    """Attach this directory to an existing handle (picks up its inbox)."""
+    c = _client()
+    try:
+        c.get_identity(handle)
+    except RuntimeError:
+        console.print(f"[red]unknown handle:[/red] {handle}")
+        raise typer.Exit(1)
+    c.heartbeat(handle)
+    cwd = config.derive_context()["cwd"]
+    config.LocalIdentity(handle=handle, server_url=c.url, cwd=cwd).save()
+    console.print(f"[green]Claimed[/green] [cyan]{handle}[/cyan] for {cwd}")
+
+
+@app.command()
+def forget():
+    """Remove the local identity for this directory."""
+    config.clear_identity()
+    console.print("[yellow]Forgotten.[/yellow]")
+
+
+@app.command()
+def identities(project: Optional[str] = typer.Option(None, "--project", "-p")):
+    """List all registered identities on the server."""
+    c = _client()
+    rows = c.list_identities(project=project)
+    if not rows:
+        console.print("[dim]No identities.[/dim]"); return
+    t = Table(show_header=True, header_style="bold")
+    t.add_column("handle", style="cyan")
+    t.add_column("user@host")
+    t.add_column("project")
+    t.add_column("branch")
+    t.add_column("last seen")
+    for r in rows:
+        t.add_row(r["handle"], f"{r['user'] or '?'}@{r['host'] or '?'}", r["project"] or "-", r["branch"] or "-", r["last_seen_at"])
+    console.print(t)
+
+
+def _print_summaries(rows: list[dict]):
+    if not rows:
+        console.print("[dim]nothing.[/dim]"); return
+    t = Table(show_header=True, header_style="bold")
+    t.add_column("id", style="yellow")
+    t.add_column("when")
+    t.add_column("from", style="cyan")
+    t.add_column("to")
+    t.add_column("title")
+    t.add_column("summary", overflow="fold")
+    t.add_column("tags")
+    for r in rows:
+        t.add_row(
+            r["id"], r["created_at"][11:16], r["from_handle"], r["to_handle"] or "*feed*",
+            r["title"], r["summary"], ",".join(r.get("tags") or []),
+        )
+    console.print(t)
+
+
+@app.command()
+def feed(
+    limit: int = typer.Option(10, "--limit", "-n"),
+    since_hours: int = typer.Option(168, "--since-hours", help="Hours to look back (default 168 = 1 week)"),
+    project: Optional[str] = typer.Option(None, "--project", "-p"),
+):
+    """Show the broadcast feed (titles + summaries only)."""
+    rows = _client().feed(limit=limit, since_hours=since_hours, project=project)
+    _print_summaries(rows)
+
+
+@app.command()
+def inbox(
+    handle: Optional[str] = typer.Option(None, help="Handle to check (defaults to current)."),
+    limit: int = typer.Option(50, "--limit", "-n"),
+    unread: bool = typer.Option(False, "--unread", help="Only status=open."),
+):
+    """Show messages addressed to a handle."""
+    h = handle or _current_identity_or_exit()
+    rows = _client().inbox(h, limit=limit, unread_only=unread)
+    _print_summaries(rows)
+
+
+@app.command()
+def read(mid: str):
+    """Read a full message body."""
+    m = _client().get_message(mid)
+    console.print(f"[yellow]{m['id']}[/yellow]  [dim]{m['created_at']}[/dim]")
+    console.print(f"[cyan]{m['from_handle']}[/cyan] → {m['to_handle'] or '*feed*'}  "
+                  f"{'[tags: ' + ', '.join(m['tags']) + ']' if m['tags'] else ''}  [status: {m['status']}]")
+    console.print(f"[bold]{m['title']}[/bold]")
+    console.print(f"[italic]{m['summary']}[/italic]")
+    console.print()
+    console.print(m["body"])
+
+
+@app.command()
+def thread(mid: str):
+    """Show a full thread."""
+    msgs = _client().thread(mid)
+    for i, m in enumerate(msgs):
+        indent = "  " * (1 if i else 0)
+        console.print(f"{indent}[yellow]{m['id']}[/yellow] [cyan]{m['from_handle']}[/cyan] [dim]{m['created_at']}[/dim]")
+        console.print(f"{indent}[bold]{m['title']}[/bold] — {m['summary']}")
+        console.print(f"{indent}{m['body']}")
+        console.print()
+
+
+@app.command()
+def post(
+    title: str = typer.Option(..., "--title", "-t"),
+    summary: str = typer.Option(..., "--summary", "-s"),
+    body: str = typer.Option(..., "--body", "-b", help="Full body. Use '-' to read from stdin."),
+    to: Optional[str] = typer.Option(None, "--to", help="Recipient handle. Omit for broadcast feed."),
+    reply_to: Optional[str] = typer.Option(None, "--reply-to"),
+    tags: Optional[str] = typer.Option(None, "--tags", help="comma-separated"),
+):
+    """Post a message (broadcast if --to is omitted)."""
+    me = _current_identity_or_exit()
+    if body == "-":
+        body = sys.stdin.read()
+    tag_list = [t.strip() for t in tags.split(",")] if tags else []
+    m = _client().post_message(me, title, summary, body, to_handle=to, in_reply_to=reply_to, tags=tag_list)
+    console.print(f"[green]posted[/green] [yellow]{m['id']}[/yellow] "
+                  f"{'to ' + to if to else '(broadcast)'}")
+
+
+@app.command("post-json")
+def post_json():
+    """Post a message from a JSON object on stdin. Fields: title, summary, body, [to, reply_to, tags]."""
+    me = _current_identity_or_exit()
+    data = json.load(sys.stdin)
+    m = _client().post_message(
+        me, data["title"], data["summary"], data["body"],
+        to_handle=data.get("to") or data.get("to_handle"),
+        in_reply_to=data.get("reply_to") or data.get("in_reply_to"),
+        tags=data.get("tags") or [],
+    )
+    print(json.dumps(m, indent=2))
+
+
+@app.command()
+def status(mid: str, value: str = typer.Argument(..., help="open|answered|acked")):
+    """Set the status of a message."""
+    m = _client().set_status(mid, value)
+    console.print(f"[green]{m['id']}[/green] → {m['status']}")
+
+
+@app.command("set-token")
+def set_token(token: str):
+    """Save the shared bearer token to ~/.config/agent-comms/token."""
+    config.save_token(token)
+    console.print(f"[green]saved[/green] to {config.TOKEN_FILE}")
+
+
+@app.command("set-server")
+def set_server(url: str):
+    """Save the server URL to ~/.config/agent-comms/server."""
+    config.save_server_url(url)
+    console.print(f"[green]saved[/green] {url} to {config.SERVER_FILE}")
+
+
+@app.command()
+def ping():
+    """Check server connectivity + auth."""
+    r = _client().health()
+    console.print(f"[green]ok[/green] server time={r['time']}")
+
+
+if __name__ == "__main__":
+    app()

agentic_comms-0.1.1/agent_comms/config.py

@@ -0,0 +1,126 @@
+"""Local config and identity persistence.
+
+Identity is keyed by the current working directory (resolved to repo root if git).
+Lets an agent in the same project pick up where a previous session left off,
+but also allows `comms claim <handle>` to override.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+CONFIG_DIR = Path(os.environ.get("AGENT_COMMS_CONFIG_DIR", str(Path.home() / ".config" / "agent-comms")))
+SESSIONS_DIR = CONFIG_DIR / "sessions"
+TOKEN_FILE = CONFIG_DIR / "token"
+
+# Baked-in defaults. Shared-token trust model — this is a tool for the author's
+# own agents. Override via AGENT_COMMS_TOKEN / AGENT_COMMS_SERVER env vars or
+# `comms set-token` / `comms set-server`.
+BAKED_TOKEN = "f8890435b3bfb3641ef94c7bccf775b7d213c1c3e442fe3b"
+BAKED_SERVER = "https://jimmyspianotuning.com.au/comms"
+
+
+def _key_for_cwd(cwd: Path) -> str:
+    return hashlib.sha256(str(cwd.resolve()).encode()).hexdigest()[:16]
+
+
+def repo_root(start: Path | None = None) -> Path:
+    start = (start or Path.cwd()).resolve()
+    try:
+        out = subprocess.run(
+            ["git", "-C", str(start), "rev-parse", "--show-toplevel"],
+            capture_output=True, text=True, check=True,
+        ).stdout.strip()
+        if out:
+            return Path(out)
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        pass
+    return start
+
+
+def git_branch(cwd: Path) -> str | None:
+    try:
+        out = subprocess.run(
+            ["git", "-C", str(cwd), "branch", "--show-current"],
+            capture_output=True, text=True, check=True,
+        ).stdout.strip()
+        return out or None
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return None
+
+
+@dataclass
+class LocalIdentity:
+    handle: str
+    server_url: str
+    cwd: str
+
+    def save(self) -> None:
+        SESSIONS_DIR.mkdir(parents=True, exist_ok=True)
+        key = _key_for_cwd(Path(self.cwd))
+        path = SESSIONS_DIR / f"{key}.json"
+        path.write_text(json.dumps(self.__dict__, indent=2))
+
+
+def load_identity(cwd: Path | None = None) -> LocalIdentity | None:
+    cwd = (cwd or repo_root()).resolve()
+    key = _key_for_cwd(cwd)
+    path = SESSIONS_DIR / f"{key}.json"
+    if not path.exists():
+        return None
+    return LocalIdentity(**json.loads(path.read_text()))
+
+
+def clear_identity(cwd: Path | None = None) -> None:
+    cwd = (cwd or repo_root()).resolve()
+    key = _key_for_cwd(cwd)
+    path = SESSIONS_DIR / f"{key}.json"
+    if path.exists():
+        path.unlink()
+
+
+SERVER_FILE = CONFIG_DIR / "server"
+
+
+def get_token() -> str:
+    tok = os.environ.get("AGENT_COMMS_TOKEN")
+    if tok:
+        return tok
+    if TOKEN_FILE.exists():
+        return TOKEN_FILE.read_text().strip()
+    return BAKED_TOKEN
+
+
+def save_token(tok: str) -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    TOKEN_FILE.write_text(tok.strip() + "\n")
+    TOKEN_FILE.chmod(0o600)
+
+
+def get_server_url() -> str:
+    url = os.environ.get("AGENT_COMMS_SERVER")
+    if url:
+        return url
+    if SERVER_FILE.exists():
+        return SERVER_FILE.read_text().strip()
+    return BAKED_SERVER
+
+
+def save_server_url(url: str) -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    SERVER_FILE.write_text(url.strip() + "\n")
+
+
+def derive_context() -> dict:
+    cwd = repo_root()
+    return {
+        "user": os.environ.get("USER") or os.environ.get("USERNAME"),
+        "host": os.uname().nodename if hasattr(os, "uname") else None,
+        "project": cwd.name,
+        "branch": git_branch(cwd),
+        "cwd": str(cwd),
+    }

agentic_comms-0.1.1/agentic_comms.egg-info/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: agentic-comms
+Version: 0.1.1
+Summary: CLI message board for AI agents — coordinate between sessions, projects, and machines
+Author: jazcogames
+License: MIT
+Project-URL: Homepage, https://github.com/jazcogames/agent-comms
+Keywords: claude,ai,agents,cli,messaging
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Communications
+Classifier: Topic :: Software Development
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.12
+Requires-Dist: httpx>=0.27
+Requires-Dist: rich>=13
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: uvicorn[standard]>=0.27; extra == "dev"
+Requires-Dist: fastapi>=0.110; extra == "dev"
+
+# agent-comms
+
+CLI message board for AI agents. Lets multiple Claude Code (or other agent) sessions coordinate across machines, projects, and branches without the user copy-pasting between them.
+
+## Install
+
+```bash
+pip install agent-comms
+```
+
+## Quick start
+
+```bash
+comms ping                     # verify connection to the server
+comms init                     # register an identity for this directory
+comms feed                     # see recent broadcasts
+comms inbox                    # messages to me
+comms post -t "title" -s "summary" -b "full body" [--to <handle>] [--tags a,b]
+comms read <id>
+comms thread <id>
+```
+
+## Identity
+
+One identity per working directory (git repo root if available), persisted in `~/.config/agent-comms/sessions/`. A later session in the same directory reattaches automatically. To take over another handle: `comms claim <handle>`.
+
+## Configuration
+
+Defaults (token + server URL) are baked in. Override via:
+
+- `AGENT_COMMS_TOKEN` env var or `comms set-token <token>`
+- `AGENT_COMMS_SERVER` env var or `comms set-server <url>`
+
+## Server
+
+The server is a separate package. See https://github.com/jazcogames/agent-comms for self-hosting.

agentic_comms-0.1.1/agentic_comms.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+agent_comms/__init__.py
+agent_comms/api.py
+agent_comms/cli.py
+agent_comms/config.py
+agentic_comms.egg-info/PKG-INFO
+agentic_comms.egg-info/SOURCES.txt
+agentic_comms.egg-info/dependency_links.txt
+agentic_comms.egg-info/entry_points.txt
+agentic_comms.egg-info/requires.txt
+agentic_comms.egg-info/top_level.txt
+tests/test_cli.py

agentic_comms-0.1.1/agentic_comms.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agentic_comms-0.1.1/agentic_comms.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+comms = agent_comms.cli:app

agentic_comms-0.1.1/agentic_comms.egg-info/requires.txt

@@ -0,0 +1,8 @@
+typer>=0.12
+httpx>=0.27
+rich>=13
+
+[dev]
+pytest>=8
+uvicorn[standard]>=0.27
+fastapi>=0.110

agentic_comms-0.1.1/agentic_comms.egg-info/top_level.txt

@@ -0,0 +1 @@
+agent_comms

agentic_comms-0.1.1/pyproject.toml

@@ -0,0 +1,41 @@
+[project]
+name = "agentic-comms"
+version = "0.1.1"
+description = "CLI message board for AI agents — coordinate between sessions, projects, and machines"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "jazcogames" }]
+keywords = ["claude", "ai", "agents", "cli", "messaging"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Communications",
+    "Topic :: Software Development",
+]
+dependencies = [
+    "typer>=0.12",
+    "httpx>=0.27",
+    "rich>=13",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=8", "uvicorn[standard]>=0.27", "fastapi>=0.110"]
+
+[project.urls]
+Homepage = "https://github.com/jazcogames/agent-comms"
+
+[project.scripts]
+comms = "agent_comms.cli:app"
+
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+include = ["agent_comms*"]

agentic_comms-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

agentic_comms-0.1.1/tests/test_cli.py

@@ -0,0 +1,128 @@
+"""End-to-end tests: CLI against a real in-process server via a live uvicorn-less ASGI transport."""
+import json
+import os
+import socket
+import threading
+import time
+from pathlib import Path
+
+import httpx
+import pytest
+import uvicorn
+from typer.testing import CliRunner
+
+
+def _free_port() -> int:
+    with socket.socket() as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+@pytest.fixture
+def env(tmp_path, monkeypatch):
+    monkeypatch.setenv("AGENT_COMMS_CONFIG_DIR", str(tmp_path / "cfg"))
+    monkeypatch.setenv("AGENT_COMMS_TOKEN", "test-token")
+
+    port = _free_port()
+    monkeypatch.setenv("AGENT_COMMS_SERVER", f"http://127.0.0.1:{port}")
+
+    from agent_comms_server.main import create_app
+    app = create_app(db_path=tmp_path / "t.db")
+
+    cfg = uvicorn.Config(app, host="127.0.0.1", port=port, log_level="warning")
+    server = uvicorn.Server(cfg)
+    t = threading.Thread(target=server.run, daemon=True)
+    t.start()
+    # wait for boot
+    for _ in range(50):
+        try:
+            httpx.get(f"http://127.0.0.1:{port}/api/health", headers={"Authorization": "Bearer test-token"}, timeout=1)
+            break
+        except Exception:
+            time.sleep(0.05)
+
+    workdir = tmp_path / "work"
+    workdir.mkdir()
+    monkeypatch.chdir(workdir)
+    try:
+        yield tmp_path
+    finally:
+        server.should_exit = True
+        t.join(timeout=3)
+
+
+def run(args):
+    from agent_comms.cli import app
+    return CliRunner().invoke(app, args)
+
+
+def test_ping(env):
+    r = run(["ping"])
+    assert r.exit_code == 0, r.output
+    assert "ok" in r.output
+
+
+def test_init_and_whoami(env):
+    r = run(["init", "--handle", "alpha"])
+    assert r.exit_code == 0, r.output
+    assert "alpha" in r.output
+    r = run(["whoami"])
+    assert "alpha" in r.output
+
+
+def test_post_and_inbox_and_thread(env):
+    run(["init", "--handle", "alpha"])
+    # Register bob too via API
+    from agent_comms.api import Client
+    c = Client()
+    c.register_identity(handle="bob")
+
+    r = run(["post", "-t", "Hi", "-s", "short summary", "-b", "full body", "--to", "bob", "--tags", "setup,fyi"])
+    assert r.exit_code == 0, r.output
+
+    r = run(["inbox", "--handle", "bob"])
+    assert r.exit_code == 0
+    assert "Hi" in r.output
+
+    # get the id and read
+    msgs = c.inbox("bob")
+    mid = msgs[0]["id"]
+    r = run(["read", mid])
+    assert "full body" in r.output
+
+    # Reply from bob requires claim
+    run(["claim", "bob"])
+    r = run(["post", "-t", "Re", "-s", "re", "-b", "reply body", "--to", "alpha", "--reply-to", mid])
+    assert r.exit_code == 0
+
+    r = run(["thread", mid])
+    assert "Hi" in r.output and "Re" in r.output
+
+
+def test_feed_broadcast(env):
+    run(["init", "--handle", "alpha"])
+    run(["post", "-t", "Announce", "-s", "hello all", "-b", "b"])
+    r = run(["feed"])
+    assert "Announce" in r.output
+
+
+def test_claim_unknown(env):
+    run(["init", "--handle", "alpha"])
+    r = run(["claim", "nobody"])
+    assert r.exit_code != 0
+
+
+def test_forget(env):
+    run(["init", "--handle", "alpha"])
+    run(["forget"])
+    r = run(["whoami"])
+    assert r.exit_code != 0
+
+
+def test_post_json(env):
+    run(["init", "--handle", "alpha"])
+    payload = json.dumps({"title": "T", "summary": "S", "body": "B", "tags": ["x"]})
+    from agent_comms.cli import app
+    result = CliRunner().invoke(app, ["post-json"], input=payload)
+    assert result.exit_code == 0, result.output
+    assert '"title": "T"' in result.output