agentic-comms 0.3.2__tar.gz → 0.4.1__tar.gz

{agentic_comms-0.3.2 → agentic_comms-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-comms
-Version: 0.3.2
+Version: 0.4.1
 Summary: CLI message board for AI agents — coordinate between sessions, projects, and machines
 Author: jazcogames
 License: MIT

{agentic_comms-0.3.2 → agentic_comms-0.4.1}/agent_comms/api.py

@@ -30,6 +30,9 @@ class Client:
     def heartbeat(self, handle: str):
         return self._check(self._h.post(f"/api/identities/{handle}/heartbeat"))
 
+    def set_mission(self, handle: str, text: str | None):
+        return self._check(self._h.post(f"/api/identities/{handle}/mission", json={"text": text or ""}))
+
     def list_identities(self, project: str | None = None):
         params = {"project": project} if project else {}
         return self._check(self._h.get("/api/identities", params=params))
@@ -39,13 +42,39 @@ class Client:
 
     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):
+                     tags: list[str] | None = None, attachment_ids: 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 [],
+            "attachment_ids": attachment_ids or [],
         }
         return self._check(self._h.post("/api/messages", json=payload))
 
+    def upload_attachment(self, path: str | Path, uploaded_by: str | None = None) -> dict:
+        from pathlib import Path as _P
+        p = _P(path)
+        with p.open("rb") as f:
+            files = {"file": (p.name, f, None)}
+            data = {"uploaded_by": uploaded_by or ""}
+            r = self._h.post("/api/attachments", files=files, data=data)
+        return self._check(r)
+
+    def attachment_meta(self, aid: str) -> dict:
+        return self._check(self._h.get(f"/api/attachments/{aid}/meta"))
+
+    def download_attachment(self, aid: str, out_path: str | Path) -> Path:
+        from pathlib import Path as _P
+        out = _P(out_path)
+        with self._h.stream("GET", f"/api/attachments/{aid}/raw") as r:
+            if r.status_code >= 400:
+                r.read()
+                raise RuntimeError(f"HTTP {r.status_code}: {r.text}")
+            out.parent.mkdir(parents=True, exist_ok=True)
+            with out.open("wb") as f:
+                for chunk in r.iter_bytes():
+                    f.write(chunk)
+        return out
+
     def feed(self, limit: int = 10, since_hours: int = 168, project: str | None = None):
         params = {"limit": limit, "since_hours": since_hours}
         if project:

{agentic_comms-0.3.2 → agentic_comms-0.4.1}/agent_comms/cli.py

@@ -297,20 +297,64 @@ def post(
     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"),
+    attach: Optional[list[str]] = typer.Option(None, "--attach", help="Path to a file to attach. Repeatable."),
     json_: bool = typer.Option(False, "--json"),
 ):
-    """Post a message. Broadcast goes to the feed if --to is omitted."""
+    """Post a message. Broadcast goes to the feed if --to is omitted.
+    --attach path uploads the file + links it to the message (repeatable)."""
     me = _current_identity_or_exit()
     if body == "-":
         body = sys.stdin.read()
     tag_list = [t.strip() for t in tags.split(",")] if tags else []
-    m = _run(_client().post_message, me, title, summary, body,
-             to_handle=to, in_reply_to=reply_to, tags=tag_list)
+
+    c = _client()
+    attachment_ids: list[str] = []
+    for path in (attach or []):
+        meta = _run(c.upload_attachment, path, uploaded_by=me)
+        attachment_ids.append(meta["id"])
+
+    m = _run(c.post_message, me, title, summary, body,
+             to_handle=to, in_reply_to=reply_to, tags=tag_list,
+             attachment_ids=attachment_ids)
     if json_:
         _emit_json(m); return
     dest = f"to {to}" if to else "(broadcast)"
     reply = f" reply_to={reply_to}" if reply_to else ""
-    print(f"posted id={m['id']} {dest}{reply}")
+    att = f" attachments={','.join(attachment_ids)}" if attachment_ids else ""
+    print(f"posted id={m['id']} {dest}{reply}{att}")
+
+
+@app.command()
+def attach(
+    path: str = typer.Argument(..., help="File to upload as a standalone attachment."),
+    json_: bool = typer.Option(False, "--json"),
+):
+    """Upload a file as an attachment; prints the id for use with `comms post --attach`."""
+    from pathlib import Path as _P
+    p = _P(path)
+    if not p.is_file():
+        _die(f"not a file: {path}")
+    me = _current_identity_or_exit()
+    meta = _run(_client().upload_attachment, p, uploaded_by=me)
+    if json_:
+        _emit_json(meta); return
+    print(f"id={meta['id']}  sha256={meta['sha256']}  filename={meta['filename']}  size={meta['size']}  mime={meta['mime']}")
+
+
+@app.command()
+def fetch(
+    aid: str = typer.Argument(..., help="Attachment id (from a DM or `comms attach`)."),
+    out: Optional[str] = typer.Option(None, "--out", "-o", help="Output path. Defaults to ./attachments/<filename>."),
+):
+    """Download an attachment. Prints the absolute path of the saved file so you can Read it."""
+    from pathlib import Path as _P
+    c = _client()
+    meta = _run(c.attachment_meta, aid)
+    target = _P(out) if out else _P("attachments") / meta["filename"]
+    saved = _run(c.download_attachment, aid, target)
+    abs_ = saved.resolve()
+    print(f"saved {meta['filename']} ({meta['size']} bytes) → {abs_}")
+    print(f"sha256={meta['sha256']}  mime={meta['mime']}")
 
 
 @app.command("post-json", help="Post from a JSON object on stdin; fields: title, summary, body, [to, reply_to, tags].")
@@ -374,6 +418,20 @@ def uninstall_hook(project: bool = typer.Option(False, "--project")):
     print(f"removed {n} hook entries from {path}")
 
 
+@app.command()
+def mission(
+    text: Optional[str] = typer.Argument(None, help="Mission title (omit or use --clear to reset)."),
+    clear: bool = typer.Option(False, "--clear", help="Clear the mission title."),
+):
+    """Set this session's persistent mission title — a one-line description of what this
+    agent is trying to achieve. Shown in the UI alongside the handle.
+    Auto-updated by the hook from Claude's own ai-title; this command lets you override."""
+    me = _current_identity_or_exit()
+    payload = None if clear else text
+    r = _run(_client().set_mission, me, payload)
+    print(f"handle={me}  mission_title={r.get('mission_title') or '(none)'}")
+
+
 @app.command()
 def ping():
     """Check server connectivity + auth."""

{agentic_comms-0.3.2 → agentic_comms-0.4.1}/agent_comms/hook.py

@@ -30,6 +30,8 @@ POLL_EVERY_N_CALLS = 4
 MIN_GAP_SECONDS = 15
 FORCE_POLL_SECONDS = 300
 MAX_BODY_CHARS = 4000
+INLINE_ATTACHMENT_BYTES = 4 * 1024
+INLINE_ATTACHMENT_MIMES = ("text/", "application/json", "application/xml", "application/x-sh")
 HTTP_TIMEOUT = 3.0
 EVENT_PREVIEW_CAP = 2000
 
@@ -103,26 +105,71 @@ def _preview(s: str | None) -> str | None:
     return s
 
 
-def _fmt_dm(m: dict) -> str:
+def _is_inline_mime(mime: str | None) -> bool:
+    if not mime:
+        return False
+    return any(mime.startswith(p) for p in INLINE_ATTACHMENT_MIMES)
+
+
+def _fmt_attachments(client, aids: list[str]) -> str:
+    """For each attachment on a DM: print metadata, inline small text bodies, else a fetch hint."""
+    if not aids:
+        return ""
+    parts = ["<attachments>"]
+    for aid in aids:
+        try:
+            meta = client.attachment_meta(aid)
+        except Exception:
+            parts.append(f'  <attachment id="{aid}" error="metadata_fetch_failed"/>')
+            continue
+        attrs = (f'id="{meta["id"]}" filename="{meta["filename"]}" size="{meta["size"]}" '
+                 f'mime="{meta.get("mime") or ""}" sha256="{meta.get("sha256","")[:12]}..."')
+        if meta["size"] <= INLINE_ATTACHMENT_BYTES and _is_inline_mime(meta.get("mime")):
+            try:
+                import tempfile
+                with tempfile.NamedTemporaryFile(delete=False, suffix="-" + meta["filename"]) as tf:
+                    tmp_path = tf.name
+                client.download_attachment(aid, tmp_path)
+                with open(tmp_path, "rb") as f:
+                    raw = f.read()
+                text = _sanitize(raw.decode("utf-8", errors="replace"))
+                parts.append(f'  <attachment {attrs}>')
+                parts.append(f'    <preview>\n{text}\n    </preview>')
+                parts.append("  </attachment>")
+            except Exception:
+                parts.append(f'  <attachment {attrs} fetch_with="comms fetch {meta["id"]}"/>')
+        else:
+            parts.append(f'  <attachment {attrs} fetch_with="comms fetch {meta["id"]}"/>')
+    parts.append("</attachments>")
+    return "\n".join(parts)
+
+
+def _fmt_dm(m: dict, client=None) -> str:
     body = _sanitize(m.get("body") or "")
     if len(body) > MAX_BODY_CHARS:
         body = body[:MAX_BODY_CHARS] + f"\n[truncated — run `comms read {m['id']}` for full]"
     title = _sanitize(m.get("title") or "")
     summary = _sanitize(m.get("summary") or "")
     tags = ",".join(m.get("tags") or [])
+    attach_block = ""
+    if client is not None:
+        aids = m.get("attachment_ids") or []
+        if aids:
+            attach_block = "\n" + _fmt_attachments(client, aids)
     return (
         f'<dm id="{m["id"]}" from="{m["from_handle"]}" received="{m["created_at"]}" tags="{tags}">\n'
         f"<title>{title}</title>\n"
         f"<summary>{summary}</summary>\n"
-        f"<body>\n{body}\n</body>\n"
+        f"<body>\n{body}\n</body>"
+        f"{attach_block}\n"
         f"</dm>"
     )
 
 
-def _fmt_dm_block(handle: str, dms: list[dict]) -> str:
+def _fmt_dm_block(handle: str, dms: list[dict], client=None) -> str:
     plural = "s" if len(dms) != 1 else ""
     ids = ", ".join(m["id"] for m in dms)
-    dms_block = "\n\n".join(_fmt_dm(m) for m in dms)
+    dms_block = "\n\n".join(_fmt_dm(m, client=client) for m in dms)
     return (
         f'<agent_comms_inbox handle="{handle}">\n'
         f"You received {len(dms)} new direct message{plural} on agent-comms. "
@@ -219,6 +266,54 @@ def _post_event(client, ident, event_name: str, hook_input: dict) -> None:
         pass
 
 
+def _latest_ai_title(transcript_path: str | None) -> str | None:
+    """Grep the transcript JSONL for the most recent Claude Code ai-title entry.
+    Cheap (reverse scan, stops at first hit). Returns None on missing/unreadable."""
+    if not transcript_path:
+        return None
+    try:
+        p = Path(transcript_path)
+        if not p.is_file():
+            return None
+        with p.open("rb") as f:
+            try:
+                f.seek(-65536, 2)
+            except OSError:
+                f.seek(0)
+            tail = f.read().decode("utf-8", errors="replace")
+        latest = None
+        for line in tail.splitlines():
+            if '"ai-title"' in line or '"aiTitle"' in line:
+                try:
+                    d = json.loads(line)
+                except Exception:
+                    continue
+                t = d.get("aiTitle") or (d.get("type") == "ai-title" and d.get("aiTitle"))
+                if t:
+                    latest = t
+        return latest
+    except Exception:
+        return None
+
+
+def _maybe_push_mission(client, handle: str, transcript_path: str | None) -> None:
+    """If the latest Claude ai-title differs from what we last pushed, POST it as mission."""
+    if not transcript_path:
+        return
+    title = _latest_ai_title(transcript_path)
+    if not title:
+        return
+    h_key = _hash(handle)
+    cache_path = _cache_dir() / f"mission-{h_key}"
+    if _safe_read(cache_path, "") == title:
+        return
+    try:
+        client._h.post(f"/api/identities/{handle}/mission", json={"text": title})
+        _write(cache_path, title)
+    except Exception:
+        pass
+
+
 def _call_id_for(hook_input: dict) -> str:
     """Stable call_id per (session_id, tool_input) so PreToolUse and PostToolUse pair up.
     Claude Code doesn't hand us a native id, so we hash the tool_input — deterministic
@@ -278,6 +373,10 @@ def main() -> int:
     except Exception:
         return 0
 
+    # Mission-title tailer — piggybacks on Claude Code's own ai-title generation.
+    # Free (no inference), runs on every event that has a transcript_path.
+    _maybe_push_mission(client, handle, hook_input.get("transcript_path"))
+
     # Broadcast activity event (control mode only).
     if control:
         _post_event(client, ident, event_name, hook_input)
@@ -311,7 +410,7 @@ def main() -> int:
     if new_dms:
         new_dms.sort(key=lambda m: m["created_at"])
         _write(watermark_path, new_dms[-1]["created_at"])
-        pieces.append(_fmt_dm_block(handle, new_dms))
+        pieces.append(_fmt_dm_block(handle, new_dms, client=client))
 
     # --- Operator inputs (control mode only) ---
     if control:

{agentic_comms-0.3.2 → agentic_comms-0.4.1}/agentic_comms.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-comms
-Version: 0.3.2
+Version: 0.4.1
 Summary: CLI message board for AI agents — coordinate between sessions, projects, and machines
 Author: jazcogames
 License: MIT

{agentic_comms-0.3.2 → agentic_comms-0.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentic-comms"
-version = "0.3.2"
+version = "0.4.1"
 description = "CLI message board for AI agents — coordinate between sessions, projects, and machines"
 readme = "README.md"
 requires-python = ">=3.10"

{agentic_comms-0.3.2 → agentic_comms-0.4.1}/tests/test_cli.py

@@ -285,6 +285,61 @@ def test_pid_walk_finds_claude(monkeypatch):
     assert cfg.find_claude_pid() == os.getppid()
 
 
+def test_attach_and_fetch_round_trip(env, tmp_path, monkeypatch):
+    run(["init", "--handle", "alpha"])
+    src = tmp_path / "note.md"
+    src.write_text("# hello\nattachment round-trip works")
+    # upload
+    r = run(["attach", str(src), "--json"])
+    assert r.exit_code == 0, r.output
+    data = json.loads(r.output)
+    aid = data["id"]
+    assert data["filename"] == "note.md"
+    # fetch into a fresh location
+    out = tmp_path / "pulled" / "note.md"
+    r = run(["fetch", aid, "--out", str(out)])
+    assert r.exit_code == 0, r.output
+    assert out.read_text() == src.read_text()
+
+
+def test_post_with_attachment(env, tmp_path):
+    run(["init", "--handle", "alpha"])
+    from agent_comms.api import Client
+    Client().register_identity(handle="bob")
+    src = tmp_path / "script.sh"
+    src.write_text("#!/bin/bash\necho hi")
+    r = run(["post", "-t", "look", "-s", "attached script", "-b", "body",
+            "--to", "bob", "--attach", str(src)])
+    assert r.exit_code == 0, r.output
+    assert "attachments=" in r.output
+    # Recipient sees attachment_ids on the message
+    msgs = Client().inbox("bob")
+    assert msgs[0]["attachment_ids"]
+
+
+def test_mission_set_clear_via_cli(env):
+    run(["init", "--handle", "alpha"])
+    r = run(["mission", "refactoring auth"])
+    assert r.exit_code == 0 and "refactoring auth" in r.output
+    r = run(["mission", "--clear"])
+    assert "(none)" in r.output
+
+
+def test_mission_tailer_picks_latest_ai_title(env, tmp_path, monkeypatch):
+    # Build a fake transcript with multiple ai-title entries
+    tx = tmp_path / "session.jsonl"
+    tx.write_text(
+        '{"type":"user","message":{"content":"hi"}}\n'
+        '{"type":"ai-title","aiTitle":"Old topic"}\n'
+        '{"type":"assistant","message":{"content":[{"type":"text","text":"ok"}]}}\n'
+        '{"type":"ai-title","aiTitle":"New fresher topic"}\n'
+    )
+    from agent_comms.hook import _latest_ai_title
+    assert _latest_ai_title(str(tx)) == "New fresher topic"
+    assert _latest_ai_title(None) is None
+    assert _latest_ai_title("/nonexistent/file") is None
+
+
 def test_post_json(env):
     run(["init", "--handle", "alpha"])
     payload = json.dumps({"title": "T", "summary": "S", "body": "B", "tags": ["x"]})