agentirc-cli 1.0.4__tar.gz → 1.0.5__tar.gz

{agentirc_cli-1.0.4 → agentirc_cli-1.0.5}/CHANGELOG.md

@@ -4,6 +4,22 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [1.0.5] - 2026-04-05
+
+
+### Changed
+
+- Extract helper methods from socket_server _handle_client (all backends)
+- Convert irc_transport _handle to dispatch table (all backends)
+- Extract _auto_approve and _flush_accumulated_text in codex/acp agent_runner
+- Extract _handle_session_update and _extract_response_text in acp/copilot agent_runner
+- Decompose _handle_roommeta into query/update methods in rooms.py
+- Extract _merge_room_metadata in server_link.py
+- Extract _attempt_single_reconnect in ircd.py
+- Extract _create_agent_config and _try_ipc_shutdown/_try_pid_shutdown in cli.py
+- Update packages/agent-harness templates to match backend features
+- Add socket_server and irc_transport to sonar CPD exclusions
+
 ## [1.0.4] - 2026-04-05
 
 

{agentirc_cli-1.0.4 → agentirc_cli-1.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentirc-cli
-Version: 1.0.4
+Version: 1.0.5
 Summary: Legacy alias for culture — install culture instead
 Project-URL: Homepage, https://github.com/OriNachum/culture
 Author: Ori Nachum

{agentirc_cli-1.0.4 → agentirc_cli-1.0.5}/culture/cli.py

@@ -525,55 +525,27 @@ def _server_status(args: argparse.Namespace) -> None:
 # -----------------------------------------------------------------------
 
 
-def _cmd_init(args: argparse.Namespace) -> None:
-    config = load_config_or_default(args.config)
-
-    # Determine server name
-    server_name = args.server or config.server.name or "culture"
-
-    # Determine agent suffix
-    if args.nick:
-        suffix = args.nick
-    else:
-        dirname = os.path.basename(os.getcwd())
-        suffix = sanitize_agent_name(dirname)
-
-    full_nick = f"{server_name}-{suffix}"
-
-    # Check for collision
-    for existing in config.agents:
-        if existing.nick == full_nick:
-            channels = existing.channels if isinstance(existing.channels, list) else []
-            print(f"Agent '{full_nick}' already exists in config", file=sys.stderr)
-            print(f"  Directory: {existing.directory}", file=sys.stderr)
-            print(f"  Backend:   {existing.agent}", file=sys.stderr)
-            print(f"  Channels:  {', '.join(channels)}", file=sys.stderr)
-            print(f"  Model:     {existing.model}", file=sys.stderr)
-            print(f"  Config:    {args.config}", file=sys.stderr)
-            print(file=sys.stderr)
-            print(f"Start with: culture start {full_nick}", file=sys.stderr)
-            sys.exit(1)
-
-    # Use backend-specific config for correct defaults
+def _create_agent_config(args: argparse.Namespace, full_nick: str) -> "AgentConfig":
+    """Build a backend-specific AgentConfig from CLI args."""
     if args.agent == "codex":
         from culture.clients.codex.config import AgentConfig as CodexAgentConfig
 
-        agent = CodexAgentConfig(
+        return CodexAgentConfig(
             nick=full_nick,
             agent="codex",
             directory=os.getcwd(),
             channels=["#general"],
         )
-    elif args.agent == "copilot":
+    if args.agent == "copilot":
         from culture.clients.copilot.config import AgentConfig as CopilotAgentConfig
 
-        agent = CopilotAgentConfig(
+        return CopilotAgentConfig(
             nick=full_nick,
             agent="copilot",
             directory=os.getcwd(),
             channels=["#general"],
         )
-    elif args.agent == "acp":
+    if args.agent == "acp":
         import json as _json
 
         from culture.clients.acp.config import AgentConfig as ACPAgentConfig
@@ -583,7 +555,6 @@ def _cmd_init(args: argparse.Namespace) -> None:
             try:
                 acp_cmd = _json.loads(args.acp_command)
             except _json.JSONDecodeError:
-                # Treat as a simple command name (e.g. "cline --acp")
                 acp_cmd = args.acp_command.split()
         if (
             not isinstance(acp_cmd, list)
@@ -592,20 +563,51 @@ def _cmd_init(args: argparse.Namespace) -> None:
         ):
             print("Error: --acp-command must be a non-empty list of strings", file=sys.stderr)
             sys.exit(1)
-        agent = ACPAgentConfig(
+        return ACPAgentConfig(
             nick=full_nick,
             agent="acp",
             acp_command=acp_cmd,
             directory=os.getcwd(),
             channels=["#general"],
         )
+    return AgentConfig(
+        nick=full_nick,
+        agent=args.agent,
+        directory=os.getcwd(),
+        channels=["#general"],
+    )
+
+
+def _cmd_init(args: argparse.Namespace) -> None:
+    config = load_config_or_default(args.config)
+
+    # Determine server name
+    server_name = args.server or config.server.name or "culture"
+
+    # Determine agent suffix
+    if args.nick:
+        suffix = args.nick
     else:
-        agent = AgentConfig(
-            nick=full_nick,
-            agent=args.agent,
-            directory=os.getcwd(),
-            channels=["#general"],
-        )
+        dirname = os.path.basename(os.getcwd())
+        suffix = sanitize_agent_name(dirname)
+
+    full_nick = f"{server_name}-{suffix}"
+
+    # Check for collision
+    for existing in config.agents:
+        if existing.nick == full_nick:
+            channels = existing.channels if isinstance(existing.channels, list) else []
+            print(f"Agent '{full_nick}' already exists in config", file=sys.stderr)
+            print(f"  Directory: {existing.directory}", file=sys.stderr)
+            print(f"  Backend:   {existing.agent}", file=sys.stderr)
+            print(f"  Channels:  {', '.join(channels)}", file=sys.stderr)
+            print(f"  Model:     {existing.model}", file=sys.stderr)
+            print(f"  Config:    {args.config}", file=sys.stderr)
+            print(file=sys.stderr)
+            print(f"Start with: culture start {full_nick}", file=sys.stderr)
+            sys.exit(1)
+
+    agent = _create_agent_config(args, full_nick)
 
     add_agent_to_config(args.config, agent, server_name=server_name)
 
@@ -853,35 +855,46 @@ def _cmd_stop(args: argparse.Namespace) -> None:
 
 def _stop_agent(nick: str) -> None:
     """Stop a single agent by trying IPC shutdown first, then PID file."""
-    # Try Unix socket IPC shutdown
     socket_path = os.path.join(
         os.environ.get("XDG_RUNTIME_DIR", "/tmp"),
         f"culture-{nick}.sock",
     )
 
-    if os.path.exists(socket_path):
-        try:
-            success = asyncio.run(_ipc_shutdown(socket_path))
-            if success:
-                print(f"Agent '{nick}' shutdown requested via IPC")
-                # Wait for process to exit
-                pid_name = f"agent-{nick}"
-                pid = read_pid(pid_name)
-                if pid:
-                    for _ in range(50):
-                        if not is_process_alive(pid):
-                            remove_pid(pid_name)
-                            print(f"Agent '{nick}' stopped")
-                            return
-                        time.sleep(0.1)
-                    # If still alive after 5s, fall through to SIGTERM
-                else:
-                    print(f"Agent '{nick}' stopped")
-                    return
-        except Exception:
-            pass  # Fall through to PID-based stop
+    if _try_ipc_shutdown(nick, socket_path):
+        return
+
+    _try_pid_shutdown(nick)
+
+
+def _try_ipc_shutdown(nick: str, socket_path: str) -> bool:
+    """Attempt graceful IPC shutdown. Return True if the agent stopped."""
+    if not os.path.exists(socket_path):
+        return False
+    try:
+        success = asyncio.run(_ipc_shutdown(socket_path))
+        if not success:
+            return False
+    except Exception:
+        return False
 
-    # Fall back to PID file
+    print(f"Agent '{nick}' shutdown requested via IPC")
+    pid_name = f"agent-{nick}"
+    pid = read_pid(pid_name)
+    if not pid:
+        print(f"Agent '{nick}' stopped")
+        return True
+    for _ in range(50):
+        if not is_process_alive(pid):
+            remove_pid(pid_name)
+            print(f"Agent '{nick}' stopped")
+            return True
+        time.sleep(0.1)
+    # Still alive after 5s — fall through to PID-based stop
+    return False
+
+
+def _try_pid_shutdown(nick: str) -> None:
+    """Stop an agent via PID file with SIGTERM/SIGKILL fallback."""
     pid_name = f"agent-{nick}"
     pid = read_pid(pid_name)
 
@@ -907,16 +920,14 @@ def _stop_agent(nick: str) -> None:
     # Force kill
     if sys.platform == "win32":
         print(f"Agent '{nick}' did not stop gracefully, terminating")
-        try:
-            os.kill(pid, signal.SIGTERM)
-        except ProcessLookupError:
-            pass
+        sig = signal.SIGTERM
     else:
         print(f"Agent '{nick}' did not stop gracefully, sending SIGKILL")
-        try:
-            os.kill(pid, signal.SIGKILL)
-        except ProcessLookupError:
-            pass
+        sig = signal.SIGKILL
+    try:
+        os.kill(pid, sig)
+    except ProcessLookupError:
+        pass
     remove_pid(pid_name)
     print(f"Agent '{nick}' killed")
 

{agentirc_cli-1.0.4 → agentirc_cli-1.0.5}/culture/clients/acp/agent_runner.py

@@ -299,42 +299,50 @@ class ACPAgentRunner:
         params = msg.get("params", {})
 
         if method == "session/update":
-            # ACP wraps updates in params.update (not flat in params)
-            update = params.get("update", params)
-            update_type = update.get("sessionUpdate", "")
-
-            if update_type in ("agent_message_chunk", "agent_thought_chunk"):
-                # Accumulate streaming text (both message and thought chunks)
-                self._busy = True
-                content = update.get("content", {})
-                if update_type == "agent_message_chunk" and content.get("type") == "text":
-                    self._accumulated_text += content.get("text", "")
-
-            # Check for stopReason — indicates turn is complete
-            if "stopReason" in update:
-                self._busy = False
-                if self.on_message and self._accumulated_text:
-                    msg_dict = {
-                        "type": "assistant",
-                        "model": self.model,
-                        "content": [{"type": "text", "text": self._accumulated_text}],
-                    }
-                    await self.on_message(msg_dict)
-                self._accumulated_text = ""
+            await self._handle_session_update(params)
 
         elif method == "session/request_permission":
-            # Auto-approve all permission requests (file changes, commands, etc.)
-            req_id = msg.get("id")
-            if req_id is not None:
-                resp = {"jsonrpc": "2.0", "id": req_id, "result": {"approved": True}}
-                if self._process and self._process.stdin:
-                    line = json.dumps(resp) + "\n"
-                    self._process.stdin.write(line.encode())
-                    await self._process.stdin.drain()
+            await self._auto_approve(msg)
 
         elif method == "error":
             logger.error("ACP error (%s): %s", self.acp_command[0], params)
 
+    async def _handle_session_update(self, params: dict) -> None:
+        """Process a session/update notification."""
+        update = params.get("update", params)
+        update_type = update.get("sessionUpdate", "")
+
+        if update_type in ("agent_message_chunk", "agent_thought_chunk"):
+            self._busy = True
+            content = update.get("content", {})
+            if update_type == "agent_message_chunk" and content.get("type") == "text":
+                self._accumulated_text += content.get("text", "")
+
+        if "stopReason" in update:
+            self._busy = False
+            await self._flush_accumulated_text()
+
+    async def _flush_accumulated_text(self) -> None:
+        """Fire on_message with any accumulated text and reset the buffer."""
+        if self.on_message and self._accumulated_text:
+            msg_dict = {
+                "type": "assistant",
+                "model": self.model,
+                "content": [{"type": "text", "text": self._accumulated_text}],
+            }
+            await self.on_message(msg_dict)
+        self._accumulated_text = ""
+
+    async def _auto_approve(self, msg: dict) -> None:
+        """Auto-approve a permission request from the ACP process."""
+        req_id = msg.get("id")
+        if req_id is not None:
+            resp = {"jsonrpc": "2.0", "id": req_id, "result": {"approved": True}}
+            if self._process and self._process.stdin:
+                line = json.dumps(resp) + "\n"
+                self._process.stdin.write(line.encode())
+                await self._process.stdin.drain()
+
     async def _prompt_loop(self) -> None:
         """Process queued prompts one at a time."""
         try:
@@ -354,21 +362,11 @@ class ACPAgentRunner:
                         timeout=120,
                     )
 
-                    # Check if response itself signals turn completion
                     result = resp.get("result", {})
                     if "stopReason" in result:
-                        # Turn completed — flush any accumulated text
-                        if self.on_message and self._accumulated_text:
-                            msg_dict = {
-                                "type": "assistant",
-                                "model": self.model,
-                                "content": [{"type": "text", "text": self._accumulated_text}],
-                            }
-                            await self.on_message(msg_dict)
-                        self._accumulated_text = ""
+                        await self._flush_accumulated_text()
                         self._busy = False
 
-                    # Wait for turn to complete (via notifications)
                     while self._busy and self._running:
                         await asyncio.sleep(0.1)
 

{agentirc_cli-1.0.4 → agentirc_cli-1.0.5}/culture/clients/acp/irc_transport.py

@@ -41,6 +41,13 @@ class IRCTransport:
         self._reconnecting = False
         self._should_run = False
         self._background_tasks: set[asyncio.Task] = set()
+        self._cmd_handlers: dict[str, Callable] = {
+            "PING": self._on_ping,
+            "001": self._on_welcome,
+            "PRIVMSG": self._on_privmsg,
+            "NOTICE": self._on_notice,
+            "ROOMINVITE": self._on_roominvite,
+        }
 
     async def connect(self) -> None:
         self._should_run = True
@@ -152,37 +159,50 @@ class IRCTransport:
                 delay = min(delay * 2, 60)
 
     async def _handle(self, msg: Message) -> None:
-        if msg.command == "PING":
-            token = msg.params[0] if msg.params else ""
-            await self._send_raw(f"PONG :{token}")
-        elif msg.command == "001":
-            self.connected = True
-            for channel in self.channels:
-                await self._send_raw(f"JOIN {channel}")
-            # Announce agent tags on connect
-            if self.tags:
-                tags_str = ",".join(self.tags)
-                await self._send_raw(f"TAGS {self.nick} {tags_str}")
-        elif msg.command == "PRIVMSG" and len(msg.params) >= 2:
-            target = msg.params[0]
-            text = msg.params[1]
-            sender = msg.prefix.split("!")[0] if msg.prefix else "unknown"
-            if sender == self.nick:
-                return
-            if target.startswith("#"):
-                self.buffer.add(target, sender, text)
-            else:
-                self.buffer.add(f"DM:{sender}", sender, text)
-            if self.on_mention and f"@{self.nick}" in text:
-                self.on_mention(target, sender, text)
-        elif msg.command == "NOTICE" and len(msg.params) >= 2:
-            target = msg.params[0]
-            text = msg.params[1]
-            sender = msg.prefix.split("!")[0] if msg.prefix else "server"
-            if target.startswith("#"):
-                self.buffer.add(target, sender, text)
-        elif msg.command == "ROOMINVITE" and len(msg.params) >= 3:
-            channel = msg.params[0]
-            meta_text = msg.params[2]
-            if self.on_roominvite:
-                self.on_roominvite(channel, meta_text)
+        handler = self._cmd_handlers.get(msg.command)
+        if handler:
+            await handler(msg)
+
+    async def _on_ping(self, msg: Message) -> None:
+        token = msg.params[0] if msg.params else ""
+        await self._send_raw(f"PONG :{token}")
+
+    async def _on_welcome(self, msg: Message) -> None:
+        self.connected = True
+        for channel in self.channels:
+            await self._send_raw(f"JOIN {channel}")
+        if self.tags:
+            tags_str = ",".join(self.tags)
+            await self._send_raw(f"TAGS {self.nick} {tags_str}")
+
+    async def _on_privmsg(self, msg: Message) -> None:
+        if len(msg.params) < 2:
+            return
+        target = msg.params[0]
+        text = msg.params[1]
+        sender = msg.prefix.split("!")[0] if msg.prefix else "unknown"
+        if sender == self.nick:
+            return
+        if target.startswith("#"):
+            self.buffer.add(target, sender, text)
+        else:
+            self.buffer.add(f"DM:{sender}", sender, text)
+        if self.on_mention and f"@{self.nick}" in text:
+            self.on_mention(target, sender, text)
+
+    async def _on_notice(self, msg: Message) -> None:
+        if len(msg.params) < 2:
+            return
+        target = msg.params[0]
+        text = msg.params[1]
+        sender = msg.prefix.split("!")[0] if msg.prefix else "server"
+        if target.startswith("#"):
+            self.buffer.add(target, sender, text)
+
+    async def _on_roominvite(self, msg: Message) -> None:
+        if len(msg.params) < 3:
+            return
+        channel = msg.params[0]
+        meta_text = msg.params[2]
+        if self.on_roominvite:
+            self.on_roominvite(channel, meta_text)

{agentirc_cli-1.0.4 → agentirc_cli-1.0.5}/culture/clients/acp/socket_server.py

@@ -61,7 +61,14 @@ class SocketServer:
         self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
     ) -> None:
         self._clients.append(writer)
-        # Drain any queued whispers that arrived before this client connected.
+        try:
+            await self._drain_queued_whispers(writer)
+            await self._process_client_messages(reader, writer)
+        finally:
+            self._cleanup_client(writer)
+
+    async def _drain_queued_whispers(self, writer: asyncio.StreamWriter) -> None:
+        """Deliver any whispers queued before this client connected."""
         while not self._whisper_queue.empty():
             try:
                 data = self._whisper_queue.get_nowait()
@@ -71,6 +78,11 @@ class SocketServer:
                 break
             except (ConnectionError, BrokenPipeError, OSError):
                 break
+
+    async def _process_client_messages(
+        self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
+    ) -> None:
+        """Read and dispatch IPC messages until the client disconnects."""
         try:
             while True:
                 line = await reader.readline()
@@ -85,20 +97,26 @@ class SocketServer:
                     await writer.drain()
                 except Exception as exc:
                     logger.exception("Handler error for message: %s", msg)
-                    try:
-                        request_id = msg.get("id") if isinstance(msg, dict) else None
-                        err_resp = make_response(request_id or "", ok=False, error=str(exc))
-                        writer.write(encode_message(err_resp))
-                        await writer.drain()
-                    except (ConnectionError, BrokenPipeError, OSError):
+                    if not await self._send_error_response(msg, exc, writer):
                         break
         except (ConnectionError, asyncio.IncompleteReadError):
             pass
-        finally:
-            if writer in self._clients:
-                self._clients.remove(writer)
-            writer.close()
-            try:
-                await writer.wait_closed()
-            except (ConnectionError, BrokenPipeError, OSError):
-                pass
+
+    async def _send_error_response(
+        self, msg: dict, exc: Exception, writer: asyncio.StreamWriter
+    ) -> bool:
+        """Send an error response to the client. Return False if the connection broke."""
+        try:
+            request_id = msg.get("id") if isinstance(msg, dict) else None
+            err_resp = make_response(request_id or "", ok=False, error=str(exc))
+            writer.write(encode_message(err_resp))
+            await writer.drain()
+            return True
+        except (ConnectionError, BrokenPipeError, OSError):
+            return False
+
+    def _cleanup_client(self, writer: asyncio.StreamWriter) -> None:
+        """Remove client from the active list and close the connection."""
+        if writer in self._clients:
+            self._clients.remove(writer)
+        writer.close()

{agentirc_cli-1.0.4 → agentirc_cli-1.0.5}/culture/clients/claude/irc_transport.py

@@ -41,6 +41,13 @@ class IRCTransport:
         self._reconnecting = False
         self._should_run = False
         self._background_tasks: set[asyncio.Task] = set()
+        self._cmd_handlers: dict[str, Callable] = {
+            "PING": self._on_ping,
+            "001": self._on_welcome,
+            "PRIVMSG": self._on_privmsg,
+            "NOTICE": self._on_notice,
+            "ROOMINVITE": self._on_roominvite,
+        }
 
     async def connect(self) -> None:
         self._should_run = True
@@ -152,37 +159,50 @@ class IRCTransport:
                 delay = min(delay * 2, 60)
 
     async def _handle(self, msg: Message) -> None:
-        if msg.command == "PING":
-            token = msg.params[0] if msg.params else ""
-            await self._send_raw(f"PONG :{token}")
-        elif msg.command == "001":
-            self.connected = True
-            for channel in self.channels:
-                await self._send_raw(f"JOIN {channel}")
-            # Announce agent tags on connect
-            if self.tags:
-                tags_str = ",".join(self.tags)
-                await self._send_raw(f"TAGS {self.nick} {tags_str}")
-        elif msg.command == "PRIVMSG" and len(msg.params) >= 2:
-            target = msg.params[0]
-            text = msg.params[1]
-            sender = msg.prefix.split("!")[0] if msg.prefix else "unknown"
-            if sender == self.nick:
-                return
-            if target.startswith("#"):
-                self.buffer.add(target, sender, text)
-            else:
-                self.buffer.add(f"DM:{sender}", sender, text)
-            if self.on_mention and f"@{self.nick}" in text:
-                self.on_mention(target, sender, text)
-        elif msg.command == "NOTICE" and len(msg.params) >= 2:
-            target = msg.params[0]
-            text = msg.params[1]
-            sender = msg.prefix.split("!")[0] if msg.prefix else "server"
-            if target.startswith("#"):
-                self.buffer.add(target, sender, text)
-        elif msg.command == "ROOMINVITE" and len(msg.params) >= 3:
-            channel = msg.params[0]
-            meta_text = msg.params[2]
-            if self.on_roominvite:
-                self.on_roominvite(channel, meta_text)
+        handler = self._cmd_handlers.get(msg.command)
+        if handler:
+            await handler(msg)
+
+    async def _on_ping(self, msg: Message) -> None:
+        token = msg.params[0] if msg.params else ""
+        await self._send_raw(f"PONG :{token}")
+
+    async def _on_welcome(self, msg: Message) -> None:
+        self.connected = True
+        for channel in self.channels:
+            await self._send_raw(f"JOIN {channel}")
+        if self.tags:
+            tags_str = ",".join(self.tags)
+            await self._send_raw(f"TAGS {self.nick} {tags_str}")
+
+    async def _on_privmsg(self, msg: Message) -> None:
+        if len(msg.params) < 2:
+            return
+        target = msg.params[0]
+        text = msg.params[1]
+        sender = msg.prefix.split("!")[0] if msg.prefix else "unknown"
+        if sender == self.nick:
+            return
+        if target.startswith("#"):
+            self.buffer.add(target, sender, text)
+        else:
+            self.buffer.add(f"DM:{sender}", sender, text)
+        if self.on_mention and f"@{self.nick}" in text:
+            self.on_mention(target, sender, text)
+
+    async def _on_notice(self, msg: Message) -> None:
+        if len(msg.params) < 2:
+            return
+        target = msg.params[0]
+        text = msg.params[1]
+        sender = msg.prefix.split("!")[0] if msg.prefix else "server"
+        if target.startswith("#"):
+            self.buffer.add(target, sender, text)
+
+    async def _on_roominvite(self, msg: Message) -> None:
+        if len(msg.params) < 3:
+            return
+        channel = msg.params[0]
+        meta_text = msg.params[2]
+        if self.on_roominvite:
+            self.on_roominvite(channel, meta_text)