agentic-comms 0.2.0__tar.gz → 0.2.2__tar.gz

{agentic_comms-0.2.0 → agentic_comms-0.2.2}/PKG-INFO

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

agentic_comms-0.2.2/agent_comms/__main__.py

@@ -0,0 +1,5 @@
+"""`python -m agent_comms` entry point — bypasses PATH issues in non-interactive shells."""
+from .cli import app
+
+if __name__ == "__main__":
+    app()

{agentic_comms-0.2.0 → agentic_comms-0.2.2}/agent_comms/cli.py

@@ -59,6 +59,10 @@ def _run(fn, *args, **kwargs):
 
 def _current_identity_or_exit() -> str:
     ident = config.load_identity()
+    if not ident:
+        # Under Claude Code: silently auto-register so the first CLI call just works.
+        # Outside Claude: preserve the explicit "run comms init" UX (scripts/cron shouldn't spawn identities).
+        ident = config.auto_init_identity(require_claude=True)
     if not ident:
         _die("no identity for this directory. Run `comms init` or `comms claim <handle>`.")
     return ident.handle
@@ -147,8 +151,10 @@ def init(
 
 @app.command()
 def whoami(json_: bool = typer.Option(False, "--json")):
-    """Show the identity attached to this directory."""
+    """Show the identity attached to this directory (auto-creates one under Claude Code)."""
     ident = config.load_identity()
+    if not ident:
+        ident = config.auto_init_identity(require_claude=True)
     if not ident:
         _die("no identity for this directory. Run `comms init`.")
     if json_:
@@ -340,14 +346,14 @@ def set_server(url: str):
 
 @app.command("install-hook")
 def install_hook(project: bool = typer.Option(False, "--project", help="Install in .claude/settings.json (project) instead of ~/.claude/settings.json (user).")):
-    """Register a PostToolUse hook so Claude Code auto-receives new DMs mid-task.
-    Idempotent — safe to run more than once."""
+    """Register PostToolUse + UserPromptSubmit hooks so Claude Code auto-receives new DMs.
+    Idempotent — re-running will update the stored python path if it changed."""
     from . import install as inst
-    path, already = inst.install(project_scope=project)
-    if already:
-        print(f"hook already installed in {path}")
-    else:
-        print(f"installed PostToolUse hook in {path}")
+    path, status = inst.install(project_scope=project)
+    for event, s in status.items():
+        print(f"  {event}: {s}")
+    print(f"settings: {path}")
+    if any(v in ("installed", "updated") for v in status.values()):
         print("new direct messages will now appear in Claude's context automatically.")
 
 

{agentic_comms-0.2.0 → agentic_comms-0.2.2}/agent_comms/config.py

@@ -184,6 +184,34 @@ def save_server_url(url: str) -> None:
     SERVER_FILE.write_text(url.strip() + "\n")
 
 
+def auto_init_identity(claude_pid: int | None = None, require_claude: bool = True) -> "LocalIdentity | None":
+    """Silently create and register a new identity for the current cwd.
+    require_claude=True (default) means we only auto-create under Claude Code —
+    otherwise random CLI calls from cron/scripts would spam identities."""
+    if claude_pid is None:
+        claude_pid = find_claude_pid()
+    if require_claude and claude_pid is None:
+        return None
+    try:
+        import uuid as _uuid
+        from .api import Client  # local import to avoid circulars at module load
+        ctx = derive_context()
+        parts = [p for p in [ctx["user"], ctx["project"]] if p]
+        base = "-".join(parts) or "agent"
+        if ctx["branch"]:
+            base += f"-{ctx['branch']}"
+        handle = f"{base}-{_uuid.uuid4().hex[:4]}"
+        c = Client()
+        result = c.register_identity(handle=handle, **ctx)
+        ident = LocalIdentity(
+            handle=result["handle"], server_url=c.url, cwd=ctx["cwd"], claude_pid=claude_pid,
+        )
+        ident.save()
+        return ident
+    except Exception:
+        return None
+
+
 def derive_context() -> dict:
     cwd = repo_root()
     return {

{agentic_comms-0.2.0 → agentic_comms-0.2.2}/agent_comms/hook.py

@@ -89,7 +89,7 @@ def _fmt_dm(m: dict) -> str:
     )
 
 
-def _emit_context(handle: str, dms: list[dict]) -> None:
+def _emit_context(handle: str, dms: list[dict], event_name: str) -> None:
     dms_block = "\n\n".join(_fmt_dm(m) for m in dms)
     plural = "s" if len(dms) != 1 else ""
     ids = ", ".join(m["id"] for m in dms)
@@ -106,7 +106,7 @@ def _emit_context(handle: str, dms: list[dict]) -> None:
     )
     out = {
         "hookSpecificOutput": {
-            "hookEventName": "PostToolUse",
+            "hookEventName": event_name,
             "additionalContext": ctx,
         }
     }
@@ -114,32 +114,15 @@ def _emit_context(handle: str, dms: list[dict]) -> None:
 
 
 def _auto_init_identity(cwd: Path, claude_pid: int | None) -> config.LocalIdentity | None:
-    """Create an identity silently if running inside a Claude session and none exists."""
-    if claude_pid is None:
-        return None
-    try:
-        from .api import Client
-        ctx = config.derive_context()
-        parts = [p for p in [ctx["user"], ctx["project"]] if p]
-        base = "-".join(parts) or "agent"
-        if ctx["branch"]:
-            base += f"-{ctx['branch']}"
-        handle = f"{base}-{uuid.uuid4().hex[:4]}"
-        c = Client()
-        result = c.register_identity(handle=handle, **ctx)
-        ident = config.LocalIdentity(
-            handle=result["handle"], server_url=c.url, cwd=ctx["cwd"], claude_pid=claude_pid,
-        )
-        ident.save()
-        return ident
-    except Exception:
-        return None
+    """Create an identity silently. Uses the shared config.auto_init."""
+    return config.auto_init_identity(claude_pid=claude_pid, require_claude=True)
 
 
 def main() -> int:
     hook_input = _read_hook_input()
     cwd_str = hook_input.get("cwd") or str(Path.cwd())
     cwd = Path(cwd_str)
+    event_name = hook_input.get("hook_event_name") or "PostToolUse"
     claude_pid = config.find_claude_pid()
 
     ident = config.load_identity(cwd=cwd, claude_pid=claude_pid)
@@ -187,7 +170,7 @@ def main() -> int:
     newest = new_dms[-1]["created_at"]
     _write(watermark_path, newest)
 
-    _emit_context(handle, new_dms)
+    _emit_context(handle, new_dms, event_name)
     return 0
 
 

agentic_comms-0.2.2/agent_comms/install.py

@@ -0,0 +1,113 @@
+"""Install/uninstall the agent-comms Claude Code hook.
+
+Edits ~/.claude/settings.json (or .claude/settings.json with --project) to
+register a PostToolUse hook running `comms check --hook`.
+"""
+from __future__ import annotations
+
+import json
+import os
+import shlex
+import sys
+from pathlib import Path
+
+HOOK_TIMEOUT = 5
+MARKER_FIELD = "agent_comms_marker"  # embedded in the hook entry so we can find+remove
+HOOK_EVENTS = ("PostToolUse", "UserPromptSubmit")
+
+
+def _hook_command() -> str:
+    """Absolute python path + module form — works in any shell / PATH."""
+    return f"{shlex.quote(sys.executable)} -m agent_comms check --hook"
+
+
+def _settings_path(project_scope: bool) -> Path:
+    if project_scope:
+        return Path(".claude") / "settings.json"
+    claude_home = Path(os.environ.get("CLAUDE_CONFIG_DIR", str(Path.home() / ".claude")))
+    return claude_home / "settings.json"
+
+
+def _load(path: Path) -> dict:
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(path.read_text() or "{}")
+    except json.JSONDecodeError:
+        return {}
+
+
+def _save(path: Path, data: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2) + "\n")
+
+
+def install(project_scope: bool = False) -> tuple[Path, dict]:
+    """Install hooks for every event in HOOK_EVENTS. Returns (settings_path, status).
+    Idempotent — existing entries are rewritten with the current command (useful when
+    the python path changes due to venv / reinstall)."""
+    path = _settings_path(project_scope)
+    data = _load(path)
+    hooks = data.setdefault("hooks", {})
+    command = _hook_command()
+    status: dict[str, str] = {}
+
+    for event in HOOK_EVENTS:
+        entries = hooks.setdefault(event, [])
+        found = None
+        for group in entries:
+            for h in group.get("hooks", []):
+                if h.get(MARKER_FIELD):
+                    found = h
+                    break
+            if found:
+                break
+        if found:
+            if found.get("command") == command and found.get("timeout") == HOOK_TIMEOUT:
+                status[event] = "already-installed"
+            else:
+                found["command"] = command
+                found["timeout"] = HOOK_TIMEOUT
+                status[event] = "updated"
+        else:
+            entries.append({
+                "matcher": "*",
+                "hooks": [{
+                    "type": "command",
+                    "command": command,
+                    "timeout": HOOK_TIMEOUT,
+                    MARKER_FIELD: True,
+                }],
+            })
+            status[event] = "installed"
+
+    _save(path, data)
+    return path, status
+
+
+def uninstall(project_scope: bool = False) -> tuple[Path, int]:
+    """Remove any agent-comms hook entries across all events. Returns (path, num_removed)."""
+    path = _settings_path(project_scope)
+    if not path.exists():
+        return path, 0
+    data = _load(path)
+    hooks = (data.get("hooks") or {})
+    removed = 0
+    for event in list(hooks.keys()):
+        entries = hooks.get(event) or []
+        new_entries = []
+        for group in entries:
+            kept = [h for h in group.get("hooks", []) if not h.get(MARKER_FIELD)]
+            removed += len(group.get("hooks", [])) - len(kept)
+            if kept:
+                group["hooks"] = kept
+                new_entries.append(group)
+        if new_entries:
+            hooks[event] = new_entries
+        else:
+            hooks.pop(event, None)
+    if not hooks:
+        data.pop("hooks", None)
+    if removed:
+        _save(path, data)
+    return path, removed

{agentic_comms-0.2.0 → agentic_comms-0.2.2}/agentic_comms.egg-info/PKG-INFO

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

{agentic_comms-0.2.0 → agentic_comms-0.2.2}/agentic_comms.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 README.md
 pyproject.toml
 agent_comms/__init__.py
+agent_comms/__main__.py
 agent_comms/api.py
 agent_comms/cli.py
 agent_comms/config.py

{agentic_comms-0.2.0 → agentic_comms-0.2.2}/pyproject.toml

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

{agentic_comms-0.2.0 → agentic_comms-0.2.2}/tests/test_cli.py

@@ -112,7 +112,10 @@ def test_claim_unknown(env):
     assert r.exit_code != 0
 
 
-def test_forget(env):
+def test_forget(env, monkeypatch):
+    # Simulate running outside a Claude session so auto-init doesn't re-create identity.
+    from agent_comms import config as cfg
+    monkeypatch.setattr(cfg, "find_claude_pid", lambda: None)
     run(["init", "--handle", "alpha"])
     run(["forget"])
     r = run(["whoami"])
@@ -187,21 +190,24 @@ def test_install_and_uninstall_hook(env, tmp_path, monkeypatch):
     r = run(["install-hook"])
     assert r.exit_code == 0
     settings = json.loads((claude_home / "settings.json").read_text())
-    entries = settings["hooks"]["PostToolUse"]
-    assert any(
-        any(h.get("command") == "comms check --hook" for h in g.get("hooks", []))
-        for g in entries
-    )
-    # idempotent
+    assert "PostToolUse" in settings["hooks"]
+    assert "UserPromptSubmit" in settings["hooks"]
+    # command must use python -m form, not bare `comms`
+    for event in ("PostToolUse", "UserPromptSubmit"):
+        groups = settings["hooks"][event]
+        cmds = [h["command"] for g in groups for h in g.get("hooks", [])]
+        assert any("-m agent_comms" in c for c in cmds)
+    # idempotent — no duplicate entries
     r2 = run(["install-hook"])
-    assert "already installed" in r2.output
-    entries2 = json.loads((claude_home / "settings.json").read_text())["hooks"]["PostToolUse"]
-    assert len(entries2) == len(entries)
-    # uninstall
+    assert r2.exit_code == 0
+    settings2 = json.loads((claude_home / "settings.json").read_text())
+    for event in ("PostToolUse", "UserPromptSubmit"):
+        assert len(settings2["hooks"][event]) == len(settings["hooks"][event])
+    # uninstall removes both
     r3 = run(["uninstall-hook"])
     assert r3.exit_code == 0
     data = json.loads((claude_home / "settings.json").read_text())
-    assert "hooks" not in data or "PostToolUse" not in data.get("hooks", {})
+    assert "hooks" not in data or all(e not in data.get("hooks", {}) for e in ("PostToolUse", "UserPromptSubmit"))
 
 
 def test_hook_silent_when_no_dms(env, tmp_path, monkeypatch):

agentic_comms-0.2.0/agent_comms/install.py

@@ -1,91 +0,0 @@
-"""Install/uninstall the agent-comms Claude Code hook.
-
-Edits ~/.claude/settings.json (or .claude/settings.json with --project) to
-register a PostToolUse hook running `comms check --hook`.
-"""
-from __future__ import annotations
-
-import json
-import os
-from pathlib import Path
-
-HOOK_COMMAND = "comms check --hook"
-HOOK_TIMEOUT = 5
-MARKER_FIELD = "agent_comms_marker"  # embedded in the hook entry so we can find+remove
-
-
-def _settings_path(project_scope: bool) -> Path:
-    if project_scope:
-        return Path(".claude") / "settings.json"
-    claude_home = Path(os.environ.get("CLAUDE_CONFIG_DIR", str(Path.home() / ".claude")))
-    return claude_home / "settings.json"
-
-
-def _load(path: Path) -> dict:
-    if not path.exists():
-        return {}
-    try:
-        return json.loads(path.read_text() or "{}")
-    except json.JSONDecodeError:
-        return {}
-
-
-def _save(path: Path, data: dict) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(json.dumps(data, indent=2) + "\n")
-
-
-def install(project_scope: bool = False) -> tuple[Path, bool]:
-    """Install the PostToolUse hook. Returns (settings_path, already_installed_bool).
-    Idempotent — detects existing entry by marker field."""
-    path = _settings_path(project_scope)
-    data = _load(path)
-    hooks = data.setdefault("hooks", {})
-    entries = hooks.setdefault("PostToolUse", [])
-
-    for group in entries:
-        for h in group.get("hooks", []):
-            if h.get(MARKER_FIELD):
-                return path, True
-
-    entries.append({
-        "matcher": "*",
-        "hooks": [
-            {
-                "type": "command",
-                "command": HOOK_COMMAND,
-                "timeout": HOOK_TIMEOUT,
-                MARKER_FIELD: True,
-            }
-        ],
-    })
-    _save(path, data)
-    return path, False
-
-
-def uninstall(project_scope: bool = False) -> tuple[Path, int]:
-    """Remove any agent-comms hook entries. Returns (path, num_removed)."""
-    path = _settings_path(project_scope)
-    if not path.exists():
-        return path, 0
-    data = _load(path)
-    hooks = (data.get("hooks") or {})
-    entries = hooks.get("PostToolUse") or []
-    removed = 0
-    new_entries = []
-    for group in entries:
-        kept_hooks = [h for h in group.get("hooks", []) if not h.get(MARKER_FIELD)]
-        removed += len(group.get("hooks", [])) - len(kept_hooks)
-        if kept_hooks:
-            group["hooks"] = kept_hooks
-            new_entries.append(group)
-    if entries:
-        if new_entries:
-            hooks["PostToolUse"] = new_entries
-        else:
-            hooks.pop("PostToolUse", None)
-        if not hooks:
-            data.pop("hooks", None)
-    if removed:
-        _save(path, data)
-    return path, removed