promptparty 0.1.0__tar.gz

promptparty-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.pyc
+.venv/
+dist/
+build/
+*.egg-info/
+.idea/
+.vscode/

promptparty-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 k.moudra@seznam.cz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

promptparty-0.1.0/PKG-INFO

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: promptparty
+Version: 0.1.0
+Summary: Cadence sync for teams agent-coding in the same room — one dashboard that says when to PROMPT and when to TALK.
+Project-URL: Homepage, https://github.com/moudrkat/promptparty
+Project-URL: Issues, https://github.com/moudrkat/promptparty/issues
+Author-email: k.moudra@seznam.cz
+License: MIT
+License-File: LICENSE
+Keywords: agentic-coding,claude,claude-code,collaboration,hackathon,hooks,llm,pair-programming
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Communications :: Chat
+Requires-Python: >=3.10
+Requires-Dist: fastapi>=0.110
+Requires-Dist: uvicorn[standard]>=0.29
+Description-Content-Type: text/markdown
+
+# promptparty 🎉
+
+![promptparty demo — the dashboard flipping between TALK and PROMPT](https://raw.githubusercontent.com/moudrkat/promptparty/main/docs/demo.gif)
+
+**Cadence sync for teams agent-coding in the same room.** One shared dashboard
+that tells everyone when it's time to **⌨️ PROMPT** and when it's time to
+**🗣️ TALK** — because the worst part of group agentic coding is everyone
+heads-down at different moments, waiting on each other, and the conversation
+dying.
+
+The rhythm promptparty gives you:
+
+1. **⌨️ PROMPT** — someone's agent finished (or needs a permission). Read the
+   output, fire the next prompt.
+2. **🗣️ TALK** — *all* agents are generating. Hands off the keyboard: discuss
+   what's coming, plan the next move, actually talk to each other.
+3. Agents finish → the dashboard flips back to PROMPT (with an optional chime).
+
+Everyone keeps their **own terminal, own Claude Code session, own model** —
+promptparty never calls a model and needs **no API key**. It only watches the
+states.
+
+## Quickstart (60 seconds)
+
+**One person** starts the server and opens a room (put it on a big screen or a
+spare browser tab):
+
+```bash
+uvx promptparty          # or: pipx install promptparty && promptparty
+```
+
+**Each teammate** runs one command inside the project they're coding in:
+
+```bash
+uvx promptparty hooks --server http://192.168.1.20:8765 --room a1b2c3 --name Katka
+```
+
+(The dashboard's ⚙️ panel shows this exact command with your room pre-filled.)
+That installs [Claude Code hooks](https://code.claude.com/docs) into
+`./.claude/settings.json` that report automatically:
+
+| you do | dashboard shows |
+|---|---|
+| submit a prompt (`UserPromptSubmit`) | 🤖 agent running — *free to talk* |
+| agent finishes its turn (`Stop`) | ✅ agent done — *read & prompt!* |
+| agent asks for permission (`Notification`) | 🙋 needs a decision |
+
+Restart your Claude Code session (or reload hooks) and you're live.
+
+### Not using Claude Code?
+
+Any tool can report with one request — wire it into whatever hooks your tool
+has, or an alias:
+
+```bash
+curl -X POST http://SERVER:8765/api/ROOM/event \
+     -H 'content-type: application/json' \
+     -d '{"name":"Katka","state":"generating"}'
+# states: prompting | generating | ready | blocked | away
+```
+
+There are also manual buttons at the bottom of the dashboard.
+
+## What you get
+
+- 🚦 A giant phase banner: **TALK** (all agents cooking) / **PROMPT**
+  (with *who* the room is waiting on).
+- 🃏 A card per person: state, model, how long they've been in it. Blocked
+  agents pulse red so permission prompts stop rotting unnoticed.
+- 🔔 Optional chime on phase flips — you don't even need the screen in view.
+- 📊 Session stats: talk time vs prompt time and total prompts fired.
+  (Great post-hackathon bragging material.)
+- 🧹 Zero config, zero database, zero API keys. Rooms live in memory.
+
+## How it works
+
+A single FastAPI process keeps per-room state and pushes it to dashboards over
+WebSockets. Hook reports are plain HTTP POSTs. The phase rule is one line:
+
+> if every non-away member's agent is generating → **TALK**, otherwise → **PROMPT**.
+
+That's the whole trick. It works because agent turns are long enough (tens of
+seconds to minutes) that "all agents running" is a genuine conversational
+window.
+
+## Options
+
+```
+promptparty [serve] [--port 8765] [--host 0.0.0.0]
+promptparty hooks --server URL --room SLUG --name YOU [--settings PATH]
+promptparty hooks --remove [--settings PATH]
+```
+
+Playing from different networks? Put the server behind any tunnel
+(`ngrok http 8765`, `cloudflared tunnel --url http://localhost:8765`).
+
+## Roadmap
+
+- [ ] `PreCompact` / `SubagentStop` hook nuances (long multi-agent turns)
+- [ ] Per-room history graph (talk/prompt timeline you can screenshot)
+- [ ] Team pomodoro mode: enforced talk windows
+- [ ] Adapters for aider / codex / opencode hooks out of the box
+
+PRs welcome — this was born at a hackathon and stays intentionally tiny: one
+Python file of server, one HTML file of dashboard, no build step.
+
+## Security notes
+
+- Anyone with the room URL can view and post states. It's presence data, not
+  code — but run it on a network you trust.
+- Rooms are in-memory and vanish on restart.
+
+## License
+
+MIT © [moudrkat](https://github.com/moudrkat)

promptparty-0.1.0/README.md

@@ -0,0 +1,115 @@
+# promptparty 🎉
+
+![promptparty demo — the dashboard flipping between TALK and PROMPT](https://raw.githubusercontent.com/moudrkat/promptparty/main/docs/demo.gif)
+
+**Cadence sync for teams agent-coding in the same room.** One shared dashboard
+that tells everyone when it's time to **⌨️ PROMPT** and when it's time to
+**🗣️ TALK** — because the worst part of group agentic coding is everyone
+heads-down at different moments, waiting on each other, and the conversation
+dying.
+
+The rhythm promptparty gives you:
+
+1. **⌨️ PROMPT** — someone's agent finished (or needs a permission). Read the
+   output, fire the next prompt.
+2. **🗣️ TALK** — *all* agents are generating. Hands off the keyboard: discuss
+   what's coming, plan the next move, actually talk to each other.
+3. Agents finish → the dashboard flips back to PROMPT (with an optional chime).
+
+Everyone keeps their **own terminal, own Claude Code session, own model** —
+promptparty never calls a model and needs **no API key**. It only watches the
+states.
+
+## Quickstart (60 seconds)
+
+**One person** starts the server and opens a room (put it on a big screen or a
+spare browser tab):
+
+```bash
+uvx promptparty          # or: pipx install promptparty && promptparty
+```
+
+**Each teammate** runs one command inside the project they're coding in:
+
+```bash
+uvx promptparty hooks --server http://192.168.1.20:8765 --room a1b2c3 --name Katka
+```
+
+(The dashboard's ⚙️ panel shows this exact command with your room pre-filled.)
+That installs [Claude Code hooks](https://code.claude.com/docs) into
+`./.claude/settings.json` that report automatically:
+
+| you do | dashboard shows |
+|---|---|
+| submit a prompt (`UserPromptSubmit`) | 🤖 agent running — *free to talk* |
+| agent finishes its turn (`Stop`) | ✅ agent done — *read & prompt!* |
+| agent asks for permission (`Notification`) | 🙋 needs a decision |
+
+Restart your Claude Code session (or reload hooks) and you're live.
+
+### Not using Claude Code?
+
+Any tool can report with one request — wire it into whatever hooks your tool
+has, or an alias:
+
+```bash
+curl -X POST http://SERVER:8765/api/ROOM/event \
+     -H 'content-type: application/json' \
+     -d '{"name":"Katka","state":"generating"}'
+# states: prompting | generating | ready | blocked | away
+```
+
+There are also manual buttons at the bottom of the dashboard.
+
+## What you get
+
+- 🚦 A giant phase banner: **TALK** (all agents cooking) / **PROMPT**
+  (with *who* the room is waiting on).
+- 🃏 A card per person: state, model, how long they've been in it. Blocked
+  agents pulse red so permission prompts stop rotting unnoticed.
+- 🔔 Optional chime on phase flips — you don't even need the screen in view.
+- 📊 Session stats: talk time vs prompt time and total prompts fired.
+  (Great post-hackathon bragging material.)
+- 🧹 Zero config, zero database, zero API keys. Rooms live in memory.
+
+## How it works
+
+A single FastAPI process keeps per-room state and pushes it to dashboards over
+WebSockets. Hook reports are plain HTTP POSTs. The phase rule is one line:
+
+> if every non-away member's agent is generating → **TALK**, otherwise → **PROMPT**.
+
+That's the whole trick. It works because agent turns are long enough (tens of
+seconds to minutes) that "all agents running" is a genuine conversational
+window.
+
+## Options
+
+```
+promptparty [serve] [--port 8765] [--host 0.0.0.0]
+promptparty hooks --server URL --room SLUG --name YOU [--settings PATH]
+promptparty hooks --remove [--settings PATH]
+```
+
+Playing from different networks? Put the server behind any tunnel
+(`ngrok http 8765`, `cloudflared tunnel --url http://localhost:8765`).
+
+## Roadmap
+
+- [ ] `PreCompact` / `SubagentStop` hook nuances (long multi-agent turns)
+- [ ] Per-room history graph (talk/prompt timeline you can screenshot)
+- [ ] Team pomodoro mode: enforced talk windows
+- [ ] Adapters for aider / codex / opencode hooks out of the box
+
+PRs welcome — this was born at a hackathon and stays intentionally tiny: one
+Python file of server, one HTML file of dashboard, no build step.
+
+## Security notes
+
+- Anyone with the room URL can view and post states. It's presence data, not
+  code — but run it on a network you trust.
+- Rooms are in-memory and vanish on restart.
+
+## License
+
+MIT © [moudrkat](https://github.com/moudrkat)

promptparty-0.1.0/promptparty/__init__.py

@@ -0,0 +1,3 @@
+"""promptparty — multiplayer prompting for Claude."""
+
+__version__ = "0.1.0"

promptparty-0.1.0/promptparty/cli.py

@@ -0,0 +1,151 @@
+"""promptparty CLI.
+
+  promptparty                          start the server (default)
+  promptparty hooks --server URL --room SLUG --name YOU
+                                       wire Claude Code hooks in ./.claude/settings.json
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import socket
+import sys
+from pathlib import Path
+
+# Claude Code hook event -> promptparty state
+HOOK_EVENTS = {
+    "UserPromptSubmit": "generating",   # you hit enter -> agent starts working
+    "Stop": "ready",                    # agent finished its turn -> read & prompt
+    "Notification": "blocked",          # agent waits on a permission / question
+    "SessionStart": "ready",
+    "SessionEnd": "away",
+}
+MARKER = "promptparty-hook"
+
+
+def _lan_ip() -> str:
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    try:
+        s.connect(("10.255.255.255", 1))
+        return s.getsockname()[0]
+    except Exception:
+        return "127.0.0.1"
+    finally:
+        s.close()
+
+
+def cmd_serve(args: argparse.Namespace) -> None:
+    ip = _lan_ip()
+    print("\n  promptparty is up — open a room and put it on a shared screen:\n")
+    print(f"    local:   http://127.0.0.1:{args.port}/")
+    print(f"    network: http://{ip}:{args.port}/\n")
+    print("  Opening / creates a fresh room; share the /r/... URL with the room.")
+    print("  Expand the ⚙️ panel on the dashboard for the per-person hook command.\n")
+
+    import uvicorn
+
+    uvicorn.run("promptparty.server:app", host=args.host, port=args.port,
+                log_level="warning")
+
+
+def _hook_command(url: str, name: str, state: str) -> str:
+    payload = json.dumps({"name": name, "state": state})
+    return (
+        f"curl -sm2 -A {MARKER} -X POST {url} "
+        f"-H 'content-type: application/json' -d '{payload}' >/dev/null 2>&1 || true"
+    )
+
+
+def cmd_hooks(args: argparse.Namespace) -> None:
+    url = f"{args.server.rstrip('/')}/api/{args.room}/event"
+    settings_path = Path(args.settings)
+    settings_path.parent.mkdir(parents=True, exist_ok=True)
+
+    data = {}
+    if settings_path.exists():
+        try:
+            data = json.loads(settings_path.read_text())
+        except json.JSONDecodeError:
+            print(f"error: {settings_path} is not valid JSON — fix it first.",
+                  file=sys.stderr)
+            sys.exit(1)
+
+    hooks = data.setdefault("hooks", {})
+    for event, state in HOOK_EVENTS.items():
+        entries = hooks.get(event, [])
+        # drop any previous promptparty hooks (re-running updates server/room/name)
+        entries = [e for e in entries if MARKER not in json.dumps(e)]
+        entries.append({
+            "hooks": [{"type": "command",
+                       "command": _hook_command(url, args.name, state)}],
+        })
+        hooks[event] = entries
+
+    settings_path.write_text(json.dumps(data, indent=2) + "\n")
+    print(f"✓ promptparty hooks for '{args.name}' written to {settings_path}")
+    print(f"  reporting to {url}")
+    print("  Restart (or /hooks reload) your Claude Code session to pick them up.")
+    print(f"  Undo any time: promptparty hooks --remove --settings {settings_path}")
+
+
+def cmd_hooks_remove(args: argparse.Namespace) -> None:
+    settings_path = Path(args.settings)
+    if not settings_path.exists():
+        print(f"{settings_path} does not exist — nothing to remove.")
+        return
+    data = json.loads(settings_path.read_text())
+    hooks = data.get("hooks", {})
+    removed = 0
+    for event in list(hooks):
+        before = len(hooks[event])
+        hooks[event] = [e for e in hooks[event] if MARKER not in json.dumps(e)]
+        removed += before - len(hooks[event])
+        if not hooks[event]:
+            del hooks[event]
+    settings_path.write_text(json.dumps(data, indent=2) + "\n")
+    print(f"✓ removed {removed} promptparty hook(s) from {settings_path}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="promptparty",
+        description="Cadence sync for people agent-coding in the same room: "
+                    "one dashboard that says when to PROMPT and when to TALK.",
+    )
+    sub = parser.add_subparsers(dest="cmd")
+
+    p_serve = sub.add_parser("serve", help="start the server (default)")
+    p_serve.add_argument("--host", default="0.0.0.0")
+    p_serve.add_argument("--port", type=int, default=8765)
+
+    p_hooks = sub.add_parser(
+        "hooks", help="install Claude Code hooks that auto-report your agent state")
+    p_hooks.add_argument("--server", help="server URL, e.g. http://192.168.1.20:8765")
+    p_hooks.add_argument("--room", help="room slug from the dashboard URL (/r/<slug>)")
+    p_hooks.add_argument("--name", help="your name as shown on the dashboard")
+    p_hooks.add_argument("--settings", default=".claude/settings.json",
+                         help="settings file to edit (default: ./.claude/settings.json)")
+    p_hooks.add_argument("--remove", action="store_true",
+                         help="remove promptparty hooks instead of installing")
+
+    args = parser.parse_args()
+
+    if args.cmd == "hooks":
+        if args.remove:
+            cmd_hooks_remove(args)
+            return
+        missing = [f"--{k}" for k in ("server", "room", "name") if not getattr(args, k)]
+        if missing:
+            print(f"error: missing {', '.join(missing)}", file=sys.stderr)
+            sys.exit(2)
+        cmd_hooks(args)
+    else:
+        if args.cmd is None:
+            args.host, args.port = "0.0.0.0", 8765
+        cmd_serve(args)
+
+
+if __name__ == "__main__":
+    main()

promptparty-0.1.0/promptparty/server.py

@@ -0,0 +1,189 @@
+"""promptparty server — a cadence synchronizer for people agent-coding in the
+same physical room.
+
+Everyone prompts their own agent (Claude Code or anything else) in their own
+terminal; the agents report state changes here (via hooks or a curl one-liner)
+and one shared dashboard tells the room when it's time to PROMPT (someone's
+agent is waiting for input) and when it's time to TALK (all agents are
+generating — hands off the keyboard).
+
+No model is called from here and no API key is needed.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import secrets
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from fastapi import FastAPI, Request, WebSocket, WebSocketDisconnect
+from fastapi.responses import FileResponse, JSONResponse, RedirectResponse
+
+STATIC_DIR = Path(__file__).parent / "static"
+
+# Member states, in "who's holding the room up" order:
+#   blocked    — agent needs a human decision (permission prompt etc.)
+#   ready      — agent finished, output waiting to be read / next prompt due
+#   prompting  — human is typing a prompt right now
+#   generating — agent is working; the human is FREE TO TALK
+#   away       — not participating right now
+STATES = {"blocked", "ready", "prompting", "generating", "away"}
+
+app = FastAPI(title="promptparty")
+
+
+@dataclass
+class Room:
+    slug: str
+    members: dict[str, dict] = field(default_factory=dict)
+    sockets: set = field(default_factory=set)
+    phase: str = "idle"
+    phase_since: float = field(default_factory=time.time)   # display timer
+    last_flush: float = field(default_factory=time.time)    # totals accounting
+    totals: dict = field(default_factory=lambda: {"talk": 0.0, "prompt": 0.0})
+    prompts_fired: int = 0
+
+
+rooms: dict[str, Room] = {}
+
+
+def get_room(slug: str) -> Room:
+    if slug not in rooms:
+        rooms[slug] = Room(slug=slug)
+    return rooms[slug]
+
+
+def compute_phase(room: Room) -> str:
+    active = [m for m in room.members.values() if m["state"] != "away"]
+    if not active:
+        return "idle"
+    if all(m["state"] == "generating" for m in active):
+        return "talk"
+    return "prompt"
+
+
+def snapshot(room: Room) -> dict:
+    return {
+        "type": "state",
+        "room": room.slug,
+        "phase": room.phase,
+        "phase_since": room.phase_since,
+        "last_flush": room.last_flush,
+        "totals": room.totals,
+        "prompts_fired": room.prompts_fired,
+        "now": time.time(),
+        "members": [
+            {"name": n, **m} for n, m in sorted(room.members.items())
+        ],
+    }
+
+
+async def broadcast(room: Room) -> None:
+    msg = snapshot(room)
+    dead = []
+    for ws in list(room.sockets):
+        try:
+            await ws.send_json(msg)
+        except Exception:
+            dead.append(ws)
+    for ws in dead:
+        room.sockets.discard(ws)
+
+
+def _transition(room: Room) -> None:
+    """Flush elapsed time into totals and recompute the phase."""
+    now = time.time()
+    if room.phase in ("talk", "prompt"):
+        room.totals[room.phase] += now - room.last_flush
+    room.last_flush = now
+    new = compute_phase(room)
+    if new != room.phase:
+        room.phase = new
+        room.phase_since = now
+
+
+async def set_state(room: Room, name: str, state: str,
+                    detail: str = "", model: str = "") -> None:
+    name = name.strip()[:32] or "anon"
+    if state not in STATES:
+        state = "ready"
+    member = room.members.setdefault(
+        name, {"state": "ready", "since": time.time(), "detail": "", "model": ""}
+    )
+    if state == "generating" and member["state"] != "generating":
+        room.prompts_fired += 1
+    member["state"] = state
+    member["since"] = time.time()
+    member["detail"] = str(detail)[:120]
+    if model:
+        member["model"] = str(model)[:40]
+    _transition(room)
+    await broadcast(room)
+
+
+async def remove_member(room: Room, name: str) -> None:
+    room.members.pop(name, None)
+    _transition(room)
+    await broadcast(room)
+
+
+# ---------------------------------------------------------------- http api
+
+
+@app.post("/api/{slug}/event")
+async def post_event(slug: str, request: Request) -> JSONResponse:
+    """State report from a hook / curl:  {"name": "...", "state": "..."}"""
+    try:
+        data = await request.json()
+    except Exception:
+        data = {}
+    name = str(data.get("name", "anon"))
+    state = str(data.get("state", "ready"))
+    room = get_room(slug)
+    await set_state(room, name, state,
+                    detail=str(data.get("detail", "")),
+                    model=str(data.get("model", "")))
+    return JSONResponse({"ok": True, "phase": room.phase})
+
+
+@app.get("/")
+async def index() -> RedirectResponse:
+    return RedirectResponse(f"/r/{secrets.token_urlsafe(3)}", status_code=307)
+
+
+@app.get("/r/{slug}")
+async def room_page(slug: str) -> FileResponse:
+    return FileResponse(STATIC_DIR / "index.html")
+
+
+@app.get("/healthz")
+async def healthz() -> JSONResponse:
+    return JSONResponse({"ok": True, "rooms": len(rooms)})
+
+
+# ---------------------------------------------------------------- websocket
+
+
+@app.websocket("/ws/{slug}")
+async def ws_endpoint(ws: WebSocket, slug: str) -> None:
+    await ws.accept()
+    room = get_room(slug)
+    room.sockets.add(ws)
+    await ws.send_json(snapshot(room))
+    try:
+        while True:
+            msg = await ws.receive_json()
+            kind = msg.get("type")
+            if kind == "set":
+                await set_state(room, str(msg.get("name", "anon")),
+                                str(msg.get("state", "ready")))
+            elif kind == "remove":
+                await remove_member(room, str(msg.get("name", "")))
+            elif kind == "ping":
+                await ws.send_json({"type": "pong"})
+    except (WebSocketDisconnect, Exception):
+        pass
+    finally:
+        room.sockets.discard(ws)

promptparty-0.1.0/promptparty/static/index.html

@@ -0,0 +1,284 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>promptparty</title>
+<style>
+  :root {
+    --bg: #0d1117; --panel: #161b22; --panel2: #1c2330; --border: #2b3444;
+    --text: #e6edf3; --dim: #8b98a9;
+    --talk: #22c55e; --prompt: #f97316; --blocked: #f87171; --idle: #64748b;
+  }
+  * { box-sizing: border-box; }
+  html, body { height: 100%; }
+  body {
+    margin: 0; background: var(--bg); color: var(--text);
+    font: 15px/1.5 system-ui, -apple-system, "Segoe UI", sans-serif;
+    display: flex; flex-direction: column;
+  }
+  header {
+    display: flex; align-items: center; gap: 12px; padding: 10px 18px;
+    background: var(--panel); border-bottom: 1px solid var(--border);
+  }
+  header .logo { font-weight: 800; font-size: 17px; }
+  header .logo span { color: var(--prompt); }
+  header .meta { color: var(--dim); font-size: 13px; }
+  header .spacer { flex: 1; }
+  button.ghost {
+    background: none; border: 1px solid var(--border); color: var(--dim);
+    border-radius: 8px; padding: 5px 10px; font-size: 12.5px; cursor: pointer;
+  }
+  button.ghost:hover { color: var(--text); border-color: var(--dim); }
+  button.ghost.on { color: var(--talk); border-color: var(--talk); }
+
+  #banner {
+    text-align: center; padding: 34px 20px 26px; transition: background .4s;
+  }
+  #banner .phase { font-size: clamp(38px, 7vw, 72px); font-weight: 900; letter-spacing: .02em; }
+  #banner .sub { color: var(--dim); font-size: 16px; margin-top: 6px; }
+  #banner .timer { font-variant-numeric: tabular-nums; font-size: 22px; margin-top: 8px; color: var(--dim); }
+  body.phase-talk #banner { background: linear-gradient(180deg, rgba(34,197,94,.16), transparent); }
+  body.phase-talk #banner .phase { color: var(--talk); }
+  body.phase-prompt #banner { background: linear-gradient(180deg, rgba(249,115,22,.16), transparent); }
+  body.phase-prompt #banner .phase { color: var(--prompt); }
+  body.phase-idle #banner .phase { color: var(--idle); }
+
+  #members {
+    flex: 1; display: flex; flex-wrap: wrap; gap: 14px; align-content: flex-start;
+    justify-content: center; padding: 8px 20px 20px; overflow-y: auto;
+  }
+  .card {
+    width: 240px; background: var(--panel); border: 1px solid var(--border);
+    border-radius: 14px; padding: 14px 16px; position: relative;
+  }
+  .card .name { font-weight: 800; font-size: 17px; }
+  .card .model { color: var(--dim); font-size: 11.5px; }
+  .card .state { margin-top: 8px; font-weight: 700; font-size: 14px; }
+  .card .elapsed { color: var(--dim); font-size: 12.5px; font-variant-numeric: tabular-nums; }
+  .card .x {
+    position: absolute; top: 8px; right: 10px; color: var(--dim); cursor: pointer;
+    background: none; border: none; font-size: 13px;
+  }
+  .card.s-generating { border-color: rgba(34,197,94,.5); }
+  .card.s-generating .state { color: var(--talk); }
+  .card.s-ready { border-color: rgba(249,115,22,.6); }
+  .card.s-ready .state { color: var(--prompt); }
+  .card.s-prompting .state { color: var(--prompt); }
+  .card.s-blocked { border-color: rgba(248,113,113,.6); animation: pulse 1.2s infinite; }
+  .card.s-blocked .state { color: var(--blocked); }
+  .card.s-away { opacity: .45; }
+  @keyframes pulse { 50% { box-shadow: 0 0 0 4px rgba(248,113,113,.15); } }
+
+  footer {
+    display: flex; align-items: center; gap: 18px; flex-wrap: wrap;
+    padding: 10px 18px; border-top: 1px solid var(--border);
+    background: var(--panel); color: var(--dim); font-size: 13px;
+  }
+  footer b { color: var(--text); }
+  #ratio { flex: 1; min-width: 160px; height: 8px; border-radius: 4px; overflow: hidden;
+           background: var(--panel2); display: flex; }
+  #ratio .t { background: var(--talk); }
+  #ratio .p { background: var(--prompt); }
+
+  details#setup {
+    margin: 0 18px 14px; background: var(--panel); border: 1px solid var(--border);
+    border-radius: 12px; padding: 10px 16px; font-size: 13.5px;
+  }
+  details#setup summary { cursor: pointer; color: var(--dim); font-weight: 600; }
+  details#setup pre {
+    background: #0a0e14; border: 1px solid var(--border); border-radius: 8px;
+    padding: 10px 12px; overflow-x: auto; font-size: 12.5px; user-select: all;
+  }
+  details#setup .hint { color: var(--dim); }
+
+  #manual { display: flex; gap: 8px; align-items: center; flex-wrap: wrap;
+            padding: 0 18px 12px; font-size: 13px; color: var(--dim); }
+  #manual input {
+    background: var(--panel2); color: var(--text); border: 1px solid var(--border);
+    border-radius: 8px; padding: 6px 10px; font: inherit; font-size: 13px; width: 120px;
+  }
+  #manual button {
+    background: var(--panel2); color: var(--text); border: 1px solid var(--border);
+    border-radius: 8px; padding: 6px 10px; font-size: 12.5px; cursor: pointer;
+  }
+  #manual button:hover { border-color: var(--dim); }
+</style>
+</head>
+<body class="phase-idle">
+<header>
+  <div class="logo">prompt<span>party</span> 🎉</div>
+  <div class="meta" id="roommeta"></div>
+  <div class="spacer"></div>
+  <button class="ghost" id="sound">🔔 sound: off</button>
+  <button class="ghost" id="copylink">copy room link</button>
+</header>
+
+<div id="banner">
+  <div class="phase" id="phase">…</div>
+  <div class="sub" id="sub">waiting for players</div>
+  <div class="timer" id="timer"></div>
+</div>
+
+<div id="members"></div>
+
+<div id="manual">
+  <span>no hooks? report manually:</span>
+  <input id="myname" placeholder="your name" maxlength="32">
+  <button data-s="prompting">⌨️ prompting</button>
+  <button data-s="generating">🤖 agent running</button>
+  <button data-s="ready">✅ agent done</button>
+  <button data-s="away">🚪 away</button>
+</div>
+
+<details id="setup">
+  <summary>⚙️ hook up Claude Code (auto-reporting) — click to expand</summary>
+  <p>Run this once per teammate, inside the project you're coding in:</p>
+  <pre id="hookcmd"></pre>
+  <p class="hint">That installs Claude Code hooks that report your agent's state here
+  automatically: prompt submitted → <b>agent running</b>, turn finished → <b>agent done</b>,
+  permission needed → <b>blocked</b>. Any other tool can report with:</p>
+  <pre id="curlcmd"></pre>
+</details>
+
+<footer>
+  <span>🗣 talk <b id="t-talk">0:00</b></span>
+  <div id="ratio"><div class="t" style="flex:1"></div></div>
+  <span>⌨️ prompt <b id="t-prompt">0:00</b></span>
+  <span>🚀 prompts fired: <b id="fired">0</b></span>
+</footer>
+
+<script>
+(() => {
+  const $ = (id) => document.getElementById(id);
+  const room = location.pathname.split("/").pop();
+  let ws, state = null, soundOn = false, lastPhase = null;
+
+  $("roommeta").textContent = `room ${room}`;
+  $("hookcmd").textContent =
+    `uvx promptparty hooks --server ${location.origin} --room ${room} --name YOURNAME`;
+  $("curlcmd").textContent =
+    `curl -X POST ${location.origin}/api/${room}/event -H 'content-type: application/json' \\\n` +
+    `     -d '{"name":"YOURNAME","state":"generating"}'   # or: ready | prompting | blocked | away`;
+
+  const fmt = (s) => {
+    s = Math.max(0, Math.floor(s));
+    return `${Math.floor(s / 60)}:${String(s % 60).padStart(2, "0")}`;
+  };
+
+  const STATE_LABEL = {
+    generating: "🤖 agent running — free to talk",
+    ready: "✅ agent done — read & prompt!",
+    prompting: "⌨️ typing a prompt…",
+    blocked: "🙋 needs a decision!",
+    away: "🚪 away",
+  };
+
+  function beep(freq, dur = 0.18) {
+    if (!soundOn) return;
+    try {
+      const ctx = beep.ctx || (beep.ctx = new (window.AudioContext || window.webkitAudioContext)());
+      const o = ctx.createOscillator(), g = ctx.createGain();
+      o.frequency.value = freq; o.type = "sine";
+      g.gain.setValueAtTime(0.12, ctx.currentTime);
+      g.gain.exponentialRampToValueAtTime(0.001, ctx.currentTime + dur);
+      o.connect(g); g.connect(ctx.destination);
+      o.start(); o.stop(ctx.currentTime + dur);
+    } catch (e) {}
+  }
+
+  function render() {
+    if (!state) return;
+    const drift = state._recv - state.now;  // map server clock to local
+    const now = Date.now() / 1000 - drift;
+
+    document.body.className = "phase-" + (state.phase === "idle" ? "idle" : state.phase);
+    const ph = $("phase"), sub = $("sub");
+    if (state.phase === "talk") {
+      ph.textContent = "🗣️ TALK";
+      sub.textContent = "all agents are cooking — hands off the keyboard";
+    } else if (state.phase === "prompt") {
+      const holding = state.members.filter(m => ["ready", "blocked", "prompting"].includes(m.state));
+      ph.textContent = "⌨️ PROMPT";
+      sub.textContent = holding.length
+        ? `waiting on: ${holding.map(m => m.name).join(", ")}`
+        : "get your prompts in";
+    } else {
+      ph.textContent = "promptparty";
+      sub.textContent = "waiting for players — expand ⚙️ below to join";
+    }
+    $("timer").textContent = state.phase === "idle" ? "" : fmt(now - state.phase_since);
+
+    const box = $("members");
+    box.innerHTML = "";
+    for (const m of state.members) {
+      const el = document.createElement("div");
+      el.className = "card s-" + m.state;
+      el.innerHTML = `<button class="x" title="remove">✕</button>
+        <div class="name"></div><div class="model"></div>
+        <div class="state"></div><div class="elapsed"></div>`;
+      el.querySelector(".name").textContent = m.name;
+      el.querySelector(".model").textContent = m.model || "";
+      el.querySelector(".state").textContent = STATE_LABEL[m.state] || m.state;
+      el.querySelector(".elapsed").textContent = "for " + fmt(now - m.since);
+      el.querySelector(".x").onclick = () =>
+        ws.send(JSON.stringify({ type: "remove", name: m.name }));
+      box.appendChild(el);
+    }
+
+    let talk = state.totals.talk, prompt = state.totals.prompt;
+    if (state.phase === "talk") talk += now - state.last_flush;
+    if (state.phase === "prompt") prompt += now - state.last_flush;
+    $("t-talk").textContent = fmt(talk);
+    $("t-prompt").textContent = fmt(prompt);
+    $("fired").textContent = state.prompts_fired;
+    const total = talk + prompt || 1;
+    $("ratio").innerHTML =
+      `<div class="t" style="flex:${talk / total}"></div><div class="p" style="flex:${prompt / total}"></div>`;
+  }
+
+  function connect() {
+    const proto = location.protocol === "https:" ? "wss" : "ws";
+    ws = new WebSocket(`${proto}://${location.host}/ws/${room}`);
+    ws.onclose = () => setTimeout(connect, 1500);
+    ws.onmessage = (ev) => {
+      const m = JSON.parse(ev.data);
+      if (m.type !== "state") return;
+      m._recv = Date.now() / 1000;
+      state = m;
+      if (lastPhase && m.phase !== lastPhase) {
+        if (m.phase === "talk") { beep(660); setTimeout(() => beep(880), 180); }
+        if (m.phase === "prompt") { beep(440); setTimeout(() => beep(330), 180); }
+      }
+      lastPhase = m.phase;
+      render();
+    };
+  }
+  connect();
+  setInterval(render, 1000);
+
+  $("sound").onclick = () => {
+    soundOn = !soundOn;
+    $("sound").textContent = `🔔 sound: ${soundOn ? "on" : "off"}`;
+    $("sound").classList.toggle("on", soundOn);
+    if (soundOn) beep(660);
+  };
+  $("copylink").onclick = async () => {
+    await navigator.clipboard.writeText(location.href);
+    $("copylink").textContent = "copied!";
+    setTimeout(() => $("copylink").textContent = "copy room link", 1200);
+  };
+
+  $("myname").value = localStorage.getItem("promptparty-name") || "";
+  for (const btn of document.querySelectorAll("#manual button")) {
+    btn.onclick = () => {
+      const name = $("myname").value.trim();
+      if (!name) { $("myname").focus(); return; }
+      localStorage.setItem("promptparty-name", name);
+      ws.send(JSON.stringify({ type: "set", name, state: btn.dataset.s }));
+    };
+  }
+})();
+</script>
+</body>
+</html>

promptparty-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "promptparty"
+version = "0.1.0"
+description = "Cadence sync for teams agent-coding in the same room — one dashboard that says when to PROMPT and when to TALK."
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ email = "k.moudra@seznam.cz" }]
+requires-python = ">=3.10"
+keywords = ["llm", "claude", "claude-code", "agentic-coding", "pair-programming", "collaboration", "hackathon", "hooks"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Web Environment",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Communications :: Chat",
+]
+dependencies = [
+    "fastapi>=0.110",
+    "uvicorn[standard]>=0.29",
+]
+
+[project.urls]
+Homepage = "https://github.com/moudrkat/promptparty"
+Issues = "https://github.com/moudrkat/promptparty/issues"
+
+[project.scripts]
+promptparty = "promptparty.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["promptparty"]