agentirc-cli 0.10.6__tar.gz → 0.11.0__tar.gz

agentirc_cli-0.11.0/.claude/skills/pr-review/SKILL.md

@@ -0,0 +1,184 @@
+---
+name: pr-review
+description: >
+  Full PR workflow for agentirc: branch, commit, push, create PR, wait for
+  automated reviewers, fetch comments, fix or pushback, reply, resolve threads.
+  Use when: creating PRs, handling review feedback, or the user says
+  "create PR", "review comments", "address feedback", or "resolve threads".
+---
+
+# PR Review Workflow
+
+Complete pull request lifecycle for the agentirc project. Follow every step
+in order.
+
+## Step 1 — Branch
+
+If you are on `main`, create a feature branch first:
+
+```bash
+git checkout -b <branch-name>
+```
+
+Branch naming conventions:
+
+| Type | Pattern | Example |
+|------|---------|---------|
+| Bug fix | `fix/<short-desc>` | `fix/server-not-running-crash` |
+| Feature | `feat/<short-desc>` | `feat/webhook-alerts` |
+| Docs | `docs/<short-desc>` | `docs/protocol-extensions` |
+
+## Step 2 — Make changes, commit, push
+
+1. Edit code
+2. Run tests: `uv run pytest tests/ -x -q`
+3. Bump the version (required before PR):
+
+   ```bash
+   echo '{"fixed":["..."]}' | python3 ~/.claude/skills/version-bump/scripts/bump.py patch
+   ```
+
+4. Stage and commit:
+
+   ```bash
+   git add <files>
+   git commit -m "$(cat <<'EOF'
+   Commit message here.
+
+   Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
+   EOF
+   )"
+   ```
+
+5. Push:
+
+   ```bash
+   git push -u origin <branch-name>
+   ```
+
+## Step 3 — Create PR
+
+```bash
+gh pr create --title "Short title" --body "$(cat <<'EOF'
+## Summary
+- Bullet points describing changes
+
+## Test plan
+- [ ] Test items
+
+- Claude
+EOF
+)"
+```
+
+## Step 4 — Wait for reviewers
+
+Automated reviewers (Qodo, Copilot) need time to post comments.
+
+**Wait 5 minutes** after creating the PR before checking for comments:
+
+```bash
+sleep 300
+```
+
+## Step 5 — Poll for comments
+
+After the initial wait, poll every 60 seconds until comments appear:
+
+```bash
+bash ~/.claude/skills/pr-review/scripts/pr-comments.sh <PR_NUMBER>
+```
+
+If no comments yet, wait and retry:
+
+```bash
+sleep 60
+bash ~/.claude/skills/pr-review/scripts/pr-comments.sh <PR_NUMBER>
+```
+
+Continue until at least one unresolved comment exists, or 3 consecutive polls
+return zero comments (reviewers are done / not configured).
+
+## Step 6 — Triage each comment
+
+For every review comment, decide:
+
+- **FIX** — valid concern, make the code change
+- **PUSHBACK** — disagree, explain why in the reply
+
+Guidelines:
+
+- Exception type mismatches (e.g., breaking reconnect loops) are always valid
+- Test requests are always valid — add them
+- Style nits are usually valid — fix them
+- Architecture opinions may warrant pushback if they conflict with project
+  conventions (check `CLAUDE.md` and `docs/`)
+
+## Step 7 — Fix code and push
+
+1. Make all code fixes
+2. Run tests: `uv run pytest tests/ -x -q`
+3. Commit with a descriptive message
+4. Push: `git push`
+
+## Step 8 — Reply and resolve threads
+
+Use batch mode to reply to all comments at once:
+
+```bash
+bash ~/.claude/skills/pr-review/scripts/pr-batch.sh --resolve <PR_NUMBER> <<'EOF'
+{"comment_id": 123, "body": "Fixed -- changed X to Y.\n\n- Claude"}
+{"comment_id": 456, "body": "Intentional -- this follows the pattern in Z because...\n\n- Claude"}
+EOF
+```
+
+Or reply to a single comment:
+
+```bash
+bash ~/.claude/skills/pr-review/scripts/pr-reply.sh --resolve <PR_NUMBER> <COMMENT_ID> "Fixed -- updated.\n\n- Claude"
+```
+
+**Important:**
+
+- Always sign replies with `\n\n- Claude`
+- Always use `--resolve` to resolve the thread after replying
+- Every comment must get a reply — no silent fixes
+
+## Step 9 — Wait for merge
+
+**Never merge the PR yourself.** The PR is merged manually on the GitHub site.
+
+Report completion back to the IRC channel:
+
+```bash
+# Using the IRC skill
+AGENTIRC_NICK=<your-nick> python3 -m agentirc.clients.claude.skill.irc_client \
+  send "#general" "PR #<N> — all review threads addressed and resolved. Ready for merge."
+```
+
+## Script reference
+
+| Script | Purpose |
+|--------|---------|
+| `pr-comments.sh <PR>` | Fetch all review comments |
+| `pr-reply.sh [--resolve] <PR> <ID> "body"` | Reply to one comment |
+| `pr-batch.sh [--resolve] <PR> < jsonl` | Batch reply from JSONL stdin |
+
+All scripts auto-detect `owner/repo` from the current git remote.
+
+## Quick reference — full flow
+
+```text
+git checkout -b fix/my-fix
+# ... make changes ...
+uv run pytest tests/ -x -q
+echo '{"fixed":["desc"]}' | python3 ~/.claude/skills/version-bump/scripts/bump.py patch
+git add <files> && git commit -m "message"
+git push -u origin fix/my-fix
+gh pr create --title "..." --body "..."
+sleep 300
+bash ~/.claude/skills/pr-review/scripts/pr-comments.sh <PR>
+# ... fix issues, commit, push ...
+bash ~/.claude/skills/pr-review/scripts/pr-batch.sh --resolve <PR> <<< '{"comment_id":N,"body":"Fixed\n\n- Claude"}'
+# Wait for manual merge — never merge yourself
+```

{agentirc_cli-0.10.6 → agentirc_cli-0.11.0}/CHANGELOG.md

@@ -4,6 +4,30 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [0.11.0] - 2026-03-28
+
+
+### Added
+
+- agentirc send command for sending messages to channels and agents
+- agentirc status --full flag and per-agent detailed view
+- agentirc sleep/wake commands with configurable schedule (default 23:00-08:00)
+
+
+### Changed
+
+- Extended IPC protocol with status, pause, and resume handlers
+- Added sleep_start/sleep_end config fields to DaemonConfig
+
+## [0.10.7] - 2026-03-28
+
+
+### Fixed
+
+- Fix crash with cryptic asyncio Event loop is closed errors when starting agent without IRC server running
+- Add server-running pre-check in CLI before starting agent daemon
+- Wrap IRC transport connect in try/except for clear error on connection failure
+
 ## [0.10.6] - 2026-03-28
 
 

{agentirc_cli-0.10.6 → agentirc_cli-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentirc-cli
-Version: 0.10.6
+Version: 0.11.0
 Summary: IRC protocol chatrooms for AI agents (and humans allowed)
 Project-URL: Homepage, https://github.com/OriNachum/agentirc
 Author: Ori Nachum

agentirc_cli-0.11.0/agentirc/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.11.0"

{agentirc_cli-0.10.6 → agentirc_cli-0.11.0}/agentirc/cli.py

@@ -5,10 +5,13 @@ Subcommands:
     agentirc init                       Register an agent for the current directory
     agentirc start [nick] [--all]       Start agent daemon(s)
     agentirc stop [nick] [--all]        Stop agent daemon(s)
-    agentirc status                     List running agents
+    agentirc status [nick] [--full]     List running agents (--full queries activity)
+    agentirc send <target> <message>    Send a message to a channel or agent
     agentirc read <channel>             Read recent channel messages
     agentirc who <channel>              List channel members
     agentirc channels                   List active channels
+    agentirc sleep [nick] [--all]       Pause agent(s) — stay connected but idle
+    agentirc wake [nick] [--all]        Resume paused agent(s)
 """
 from __future__ import annotations
 
@@ -115,6 +118,8 @@ def main() -> None:
 
     # -- status subcommand -------------------------------------------------
     status_parser = sub.add_parser("status", help="List running agents")
+    status_parser.add_argument("nick", nargs="?", help="Show detailed status for a specific agent")
+    status_parser.add_argument("--full", action="store_true", help="Query agents for activity status")
     status_parser.add_argument("--config", default=DEFAULT_CONFIG, help="Config file path")
 
     # -- read subcommand ---------------------------------------------------
@@ -128,10 +133,28 @@ def main() -> None:
     who_parser.add_argument("channel", help="Channel or nick target")
     who_parser.add_argument("--config", default=DEFAULT_CONFIG, help="Config file path")
 
+    # -- send subcommand ---------------------------------------------------
+    send_parser = sub.add_parser("send", help="Send a message to a channel or agent")
+    send_parser.add_argument("target", help="Channel (e.g. #general) or agent nick")
+    send_parser.add_argument("message", help="Message text to send")
+    send_parser.add_argument("--config", default=DEFAULT_CONFIG, help="Config file path")
+
     # -- channels subcommand -----------------------------------------------
     channels_parser = sub.add_parser("channels", help="List active channels")
     channels_parser.add_argument("--config", default=DEFAULT_CONFIG, help="Config file path")
 
+    # -- sleep subcommand --------------------------------------------------
+    sleep_parser = sub.add_parser("sleep", help="Pause agent(s) — stay connected but idle")
+    sleep_parser.add_argument("nick", nargs="?", help="Agent nick to pause")
+    sleep_parser.add_argument("--all", action="store_true", help="Pause all agents")
+    sleep_parser.add_argument("--config", default=DEFAULT_CONFIG, help="Config file path")
+
+    # -- wake subcommand ---------------------------------------------------
+    wake_parser = sub.add_parser("wake", help="Resume paused agent(s)")
+    wake_parser.add_argument("nick", nargs="?", help="Agent nick to resume")
+    wake_parser.add_argument("--all", action="store_true", help="Resume all agents")
+    wake_parser.add_argument("--config", default=DEFAULT_CONFIG, help="Config file path")
+
     # -- skills subcommand -------------------------------------------------
     skills_parser = sub.add_parser("skills", help="Install IRC skills for AI agents")
     skills_sub = skills_parser.add_subparsers(dest="skills_command")
@@ -159,9 +182,12 @@ def main() -> None:
             "start": _cmd_start,
             "stop": _cmd_stop,
             "status": _cmd_status,
+            "send": _cmd_send,
             "read": _cmd_read,
             "who": _cmd_who,
             "channels": _cmd_channels,
+            "sleep": _cmd_sleep,
+            "wake": _cmd_wake,
             "skills": _cmd_skills,
         }
         handler = dispatch.get(args.command)
@@ -433,6 +459,26 @@ def _cmd_start(args: argparse.Namespace) -> None:
         print("No agents configured", file=sys.stderr)
         sys.exit(1)
 
+    # Best-effort check that the IRC server is reachable before starting agent(s)
+    import socket as _socket
+
+    server_name = config.server.name
+    host, port = config.server.host, config.server.port
+    try:
+        with _socket.create_connection((host, port), timeout=2):
+            pass
+    except (ConnectionRefusedError, OSError):
+        # TCP probe failed — add PID hint if available
+        hint = ""
+        server_pid = read_pid(f"server-{server_name}")
+        if not server_pid or not is_process_alive(server_pid):
+            hint = f"\nStart it with: agentirc server start --name {server_name}"
+        print(
+            f"Error: cannot connect to IRC server at {host}:{port}.{hint}",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
     if len(agents) == 1:
         # Run in foreground (single agent)
         agent = agents[0]
@@ -632,21 +678,33 @@ def _stop_agent(nick: str) -> None:
     print(f"Agent '{nick}' killed")
 
 
-async def _ipc_shutdown(socket_path: str) -> bool:
-    """Send a shutdown command via Unix socket IPC."""
+async def _ipc_request(socket_path: str, msg_type: str, **kwargs) -> dict | None:
+    """Send an IPC request via Unix socket and return the response."""
     from agentirc.clients.claude.ipc import decode_message, encode_message, make_request
 
-    reader, writer = await asyncio.wait_for(
-        asyncio.open_unix_connection(socket_path),
-        timeout=3.0,
-    )
     try:
-        req = make_request("shutdown")
+        reader, writer = await asyncio.wait_for(
+            asyncio.open_unix_connection(socket_path),
+            timeout=3.0,
+        )
+    except (ConnectionRefusedError, FileNotFoundError, OSError):
+        return None
+    try:
+        req = make_request(msg_type, **kwargs)
         writer.write(encode_message(req))
         await writer.drain()
-        data = await asyncio.wait_for(reader.readline(), timeout=3.0)
-        resp = decode_message(data)
-        return resp is not None and resp.get("ok", False)
+        # Read lines until we get a response (skip whispers)
+        deadline = asyncio.get_event_loop().time() + 3.0
+        while True:
+            remaining = deadline - asyncio.get_event_loop().time()
+            if remaining <= 0:
+                return None
+            data = await asyncio.wait_for(reader.readline(), timeout=remaining)
+            msg = decode_message(data)
+            if msg and msg.get("type") == "response":
+                return msg
+    except (asyncio.TimeoutError, ConnectionError, BrokenPipeError, OSError):
+        return None
     finally:
         writer.close()
         try:
@@ -655,10 +713,37 @@ async def _ipc_shutdown(socket_path: str) -> bool:
             pass
 
 
+async def _ipc_shutdown(socket_path: str) -> bool:
+    """Send a shutdown command via Unix socket IPC."""
+    resp = await _ipc_request(socket_path, "shutdown")
+    return resp is not None and resp.get("ok", False)
+
+
 # -----------------------------------------------------------------------
 # Agent status
 # -----------------------------------------------------------------------
 
+def _agent_socket_path(nick: str) -> str:
+    return os.path.join(
+        os.environ.get("XDG_RUNTIME_DIR", "/tmp"),
+        f"agentirc-{nick}.sock",
+    )
+
+
+def _agent_process_status(agent) -> tuple[str, int | None]:
+    """Return (status_str, pid_or_none) for an agent."""
+    pid_name = f"agent-{agent.nick}"
+    pid = read_pid(pid_name)
+    if pid and is_process_alive(pid):
+        socket_path = _agent_socket_path(agent.nick)
+        if os.path.exists(socket_path):
+            return "running", pid
+        return "starting", pid
+    if pid:
+        remove_pid(pid_name)
+    return "stopped", None
+
+
 def _cmd_status(args: argparse.Namespace) -> None:
     config = load_config_or_default(args.config)
 
@@ -666,30 +751,64 @@ def _cmd_status(args: argparse.Namespace) -> None:
         print("No agents configured")
         return
 
-    print(f"{'NICK':<30} {'STATUS':<12} {'PID':<10}")
-    print("-" * 52)
+    # Single agent detailed view
+    if args.nick:
+        agent = None
+        for a in config.agents:
+            if a.nick == args.nick:
+                agent = a
+                break
+        if not agent:
+            print(f"Agent '{args.nick}' not found in config", file=sys.stderr)
+            sys.exit(1)
+
+        status, pid = _agent_process_status(agent)
+        print(agent.nick)
+        print(f"  Status:     {status}")
+        print(f"  PID:        {pid or '-'}")
+
+        # Query IPC for activity if running
+        if status == "running":
+            resp = asyncio.run(_ipc_request(_agent_socket_path(agent.nick), "status"))
+            if resp and resp.get("ok"):
+                data = resp.get("data", {})
+                print(f"  Activity:   {data.get('activity', 'unknown')}")
+                print(f"  Turns:      {data.get('turn_count', 0)}")
+                print(f"  Paused:     {'yes' if data.get('paused') else 'no'}")
+        else:
+            print(f"  Activity:   -")
+
+        channels = agent.channels if isinstance(agent.channels, list) else []
+        print(f"  Directory:  {agent.directory}")
+        print(f"  Backend:    {agent.agent}")
+        print(f"  Channels:   {', '.join(channels)}")
+        print(f"  Model:      {agent.model}")
+        print(f"  Config:     {args.config}")
+        return
+
+    # All agents view
+    show_activity = args.full
+
+    if show_activity:
+        print(f"{'NICK':<30} {'STATUS':<12} {'PID':<10} {'ACTIVITY':<10}")
+        print("-" * 62)
+    else:
+        print(f"{'NICK':<30} {'STATUS':<12} {'PID':<10}")
+        print("-" * 52)
 
     for agent in config.agents:
-        pid_name = f"agent-{agent.nick}"
-        pid = read_pid(pid_name)
-        status = "stopped"
-
-        if pid and is_process_alive(pid):
-            # Also check if socket is connectable
-            socket_path = os.path.join(
-                os.environ.get("XDG_RUNTIME_DIR", "/tmp"),
-                f"agentirc-{agent.nick}.sock",
-            )
-            if os.path.exists(socket_path):
-                status = "running"
-            else:
-                status = "starting"
-            print(f"{agent.nick:<30} {status:<12} {pid:<10}")
-        elif pid:
-            remove_pid(pid_name)
-            print(f"{agent.nick:<30} {'stopped':<12} {'-':<10}")
+        status, pid = _agent_process_status(agent)
+        activity = "-"
+
+        if show_activity and status == "running":
+            resp = asyncio.run(_ipc_request(_agent_socket_path(agent.nick), "status"))
+            if resp and resp.get("ok"):
+                activity = resp.get("data", {}).get("activity", "unknown")
+
+        if show_activity:
+            print(f"{agent.nick:<30} {status:<12} {str(pid or '-'):<10} {activity:<10}")
         else:
-            print(f"{agent.nick:<30} {'stopped':<12} {'-':<10}")
+            print(f"{agent.nick:<30} {status:<12} {str(pid or '-'):<10}")
 
 
 # -----------------------------------------------------------------------
@@ -708,6 +827,52 @@ def _get_observer(config_path: str):
     )
 
 
+def _ipc_to_agents(args: argparse.Namespace, msg_type: str, action_verb: str) -> None:
+    """Send an IPC message (pause/resume) to one or all agents."""
+    config = load_config_or_default(args.config)
+
+    if args.nick and args.all:
+        print(f"Cannot specify both nick and --all", file=sys.stderr)
+        sys.exit(1)
+
+    if not args.nick and not args.all:
+        print(f"Usage: agentirc {action_verb} <nick> or --all", file=sys.stderr)
+        sys.exit(1)
+
+    targets = config.agents if args.all else []
+    if args.nick:
+        for a in config.agents:
+            if a.nick == args.nick:
+                targets = [a]
+                break
+        else:
+            print(f"Agent '{args.nick}' not found in config", file=sys.stderr)
+            sys.exit(1)
+
+    for agent in targets:
+        socket_path = _agent_socket_path(agent.nick)
+        resp = asyncio.run(_ipc_request(socket_path, msg_type))
+        if resp and resp.get("ok"):
+            print(f"{agent.nick}: {action_verb}")
+        else:
+            print(f"{agent.nick}: failed (not running?)", file=sys.stderr)
+
+
+def _cmd_sleep(args: argparse.Namespace) -> None:
+    _ipc_to_agents(args, "pause", "paused")
+
+
+def _cmd_wake(args: argparse.Namespace) -> None:
+    _ipc_to_agents(args, "resume", "resumed")
+
+
+def _cmd_send(args: argparse.Namespace) -> None:
+    observer = _get_observer(args.config)
+    target = args.target if args.target.startswith("#") else args.target
+    asyncio.run(observer.send_message(target, args.message))
+    print(f"Sent to {target}")
+
+
 def _cmd_read(args: argparse.Namespace) -> None:
     observer = _get_observer(args.config)
     channel = args.channel if args.channel.startswith("#") else f"#{args.channel}"

{agentirc_cli-0.10.6 → agentirc_cli-0.11.0}/agentirc/clients/claude/config.py

@@ -56,6 +56,8 @@ class DaemonConfig:
     supervisor: SupervisorConfig = field(default_factory=SupervisorConfig)
     webhooks: WebhookConfig = field(default_factory=WebhookConfig)
     buffer_size: int = 500
+    sleep_start: str = "23:00"
+    sleep_end: str = "08:00"
     agents: list[AgentConfig] = field(default_factory=list)
 
     def get_agent(self, nick: str) -> AgentConfig | None:
@@ -84,6 +86,8 @@ def load_config(path: str | Path) -> DaemonConfig:
         supervisor=supervisor,
         webhooks=webhooks,
         buffer_size=raw.get("buffer_size", 500),
+        sleep_start=raw.get("sleep_start", "23:00"),
+        sleep_end=raw.get("sleep_end", "08:00"),
         agents=agents,
     )