agentirc-cli 4.3.2__tar.gz → 4.3.3__tar.gz

{agentirc_cli-4.3.2 → agentirc_cli-4.3.3}/CHANGELOG.md

@@ -4,6 +4,13 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [4.3.3] - 2026-04-07
+
+
+### Changed
+
+- Reduced cognitive complexity in 40 functions across 25 files to meet SonarCloud threshold (≤15)
+
 ## [4.3.2] - 2026-04-07
 
 

{agentirc_cli-4.3.2 → agentirc_cli-4.3.3}/PKG-INFO

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

{agentirc_cli-4.3.2 → agentirc_cli-4.3.3}/culture/clients/acp/agent_runner.py

@@ -220,6 +220,48 @@ class ACPAgentRunner:
         self._process.stdin.write(line.encode())
         await self._process.stdin.drain()
 
+    def _dispatch_jsonrpc_message(self, msg: dict) -> bool:
+        """Route a JSON-RPC response to its pending future.
+
+        Returns True if the message was a response (handled here),
+        False if it should be treated as a notification.
+        """
+        if "id" in msg and ("result" in msg or "error" in msg):
+            req_id = msg["id"]
+            future = self._pending.pop(req_id, None)
+            if future and not future.done():
+                future.set_result(msg)
+            return True
+        return False
+
+    async def _cleanup_process(self) -> None:
+        """Wait for process exit, fail pending futures, cancel companion tasks, fire on_exit."""
+        returncode = -1
+        if self._process:
+            try:
+                returncode = await asyncio.wait_for(self._process.wait(), timeout=5)
+            except asyncio.TimeoutError:
+                try:
+                    self._process.kill()
+                except ProcessLookupError:
+                    pass
+
+        # Fail any still-pending requests
+        for future in self._pending.values():
+            if not future.done():
+                future.set_exception(ConnectionError("Process exited"))
+        self._pending.clear()
+
+        self._running = False
+
+        # Cancel companion tasks so they don't outlive the process
+        for task in (self._task, self._stderr_task):
+            if task and not task.done():
+                task.cancel()
+
+        if not self._stopping and self.on_exit:
+            await self.on_exit(returncode)
+
     async def _read_loop(self) -> None:
         """Read JSON-RPC messages from stdout."""
         if not self._process or not self._process.stdout:
@@ -234,16 +276,9 @@ class ACPAgentRunner:
                 except json.JSONDecodeError:
                     continue
 
-                # Response to a request
-                if "id" in msg and ("result" in msg or "error" in msg):
-                    req_id = msg["id"]
-                    future = self._pending.pop(req_id, None)
-                    if future and not future.done():
-                        future.set_result(msg)
-
-                # Notification from server
-                elif "method" in msg:
-                    await self._handle_notification(msg)
+                if not self._dispatch_jsonrpc_message(msg):
+                    if "method" in msg:
+                        await self._handle_notification(msg)
 
         except asyncio.CancelledError:
             raise
@@ -252,32 +287,7 @@ class ACPAgentRunner:
         except Exception:
             logger.exception("ACP read loop error")
         finally:
-            # Wait for process to fully exit and notify daemon for crash recovery
-            returncode = -1
-            if self._process:
-                try:
-                    returncode = await asyncio.wait_for(self._process.wait(), timeout=5)
-                except asyncio.TimeoutError:
-                    try:
-                        self._process.kill()
-                    except ProcessLookupError:
-                        pass
-
-            # Fail any still-pending requests
-            for future in self._pending.values():
-                if not future.done():
-                    future.set_exception(ConnectionError("Process exited"))
-            self._pending.clear()
-
-            self._running = False
-
-            # Cancel companion tasks so they don't outlive the process
-            for task in (self._task, self._stderr_task):
-                if task and not task.done():
-                    task.cancel()
-
-            if not self._stopping and self.on_exit:
-                await self.on_exit(returncode)
+            await self._cleanup_process()
 
     async def _stderr_loop(self) -> None:
         """Log stderr output from the ACP agent process."""

{agentirc_cli-4.3.2 → agentirc_cli-4.3.3}/culture/clients/acp/daemon.py

@@ -281,27 +281,33 @@ class ACPDaemon:
         while True:
             try:
                 await asyncio.sleep(interval)
-                if self._paused or not self._agent_runner or not self._agent_runner.is_running():
-                    continue
-                for channel in self.agent.channels:
-                    msgs = self._buffer.read(channel)
-                    if not msgs:
-                        continue
-                    lines = "\n".join(f"  <{m.nick}> {m.text}" for m in msgs)
-                    prompt = (
-                        f"[IRC Channel Poll: {channel}] Recent unread messages:\n"
-                        f"{lines}\n\n"
-                        f"Respond naturally if any messages need your attention."
-                    )
-                    self._mention_targets.append(channel)
-                    task = asyncio.create_task(self._agent_runner.send_prompt(prompt))
-                    self._background_tasks.add(task)
-                    task.add_done_callback(self._background_tasks.discard)
+                self._process_poll_cycle()
             except asyncio.CancelledError:
                 raise
             except Exception:
                 logger.exception("Poll loop error")
 
+    def _process_poll_cycle(self) -> None:
+        if self._paused or not self._agent_runner or not self._agent_runner.is_running():
+            return
+        for channel in self.agent.channels:
+            self._send_channel_poll(channel)
+
+    def _send_channel_poll(self, channel) -> None:
+        msgs = self._buffer.read(channel)
+        if not msgs:
+            return
+        lines = "\n".join(f"  <{m.nick}> {m.text}" for m in msgs)
+        prompt = (
+            f"[IRC Channel Poll: {channel}] Recent unread messages:\n"
+            f"{lines}\n\n"
+            f"Respond naturally if any messages need your attention."
+        )
+        self._mention_targets.append(channel)
+        task = asyncio.create_task(self._agent_runner.send_prompt(prompt))
+        self._background_tasks.add(task)
+        task.add_done_callback(self._background_tasks.discard)
+
     async def _graceful_shutdown(self) -> None:
         """Trigger a graceful shutdown, signaling any waiting stop event."""
         logger.info("Graceful shutdown requested for %s", self.agent.nick)

{agentirc_cli-4.3.2 → agentirc_cli-4.3.3}/culture/clients/acp/skill/irc_client.py

@@ -83,14 +83,7 @@ class SkillClient:
                 msg = decode_message(line)
                 if msg is None:
                     continue
-                msg_type = msg.get("type")
-                if msg_type == MSG_TYPE_RESPONSE:
-                    req_id = msg.get("id", "")
-                    future = self._pending.pop(req_id, None)
-                    if future is not None and not future.done():
-                        future.set_result(msg)
-                elif msg_type == MSG_TYPE_WHISPER:
-                    self.pending_whispers.append(msg)
+                self._dispatch_message(msg)
         except (asyncio.IncompleteReadError, ConnectionError, OSError):
             pass
         finally:
@@ -100,6 +93,17 @@ class SkillClient:
                     future.set_exception(ConnectionError("Connection lost"))
             self._pending.clear()
 
+    def _dispatch_message(self, msg: dict[str, Any]) -> None:
+        """Route a decoded message to the appropriate handler."""
+        msg_type = msg.get("type")
+        if msg_type == MSG_TYPE_RESPONSE:
+            req_id = msg.get("id", "")
+            future = self._pending.pop(req_id, None)
+            if future is not None and not future.done():
+                future.set_result(msg)
+        elif msg_type == MSG_TYPE_WHISPER:
+            self.pending_whispers.append(msg)
+
     # ------------------------------------------------------------------
     # Request dispatch
     # ------------------------------------------------------------------
@@ -182,6 +186,86 @@ def _sock_path_from_env() -> str:
     return os.path.join(runtime_dir, f"culture-{nick}.sock")
 
 
+def _parse_ask_timeout(remaining: list[str]) -> tuple[int, list[str]]:
+    """Extract --timeout N from args, returning (timeout, filtered_args)."""
+    if "--timeout" in remaining:
+        idx = remaining.index("--timeout")
+        if idx + 1 >= len(remaining):
+            print("ERROR: --timeout requires a value", file=sys.stderr)
+            sys.exit(2)
+        try:
+            timeout = int(remaining[idx + 1])
+        except ValueError:
+            print(
+                f"ERROR: --timeout value must be an integer, got {remaining[idx + 1]!r}",
+                file=sys.stderr,
+            )
+            sys.exit(2)
+        if timeout <= 0:
+            print("ERROR: --timeout must be positive", file=sys.stderr)
+            sys.exit(2)
+        remaining = remaining[:idx] + remaining[idx + 2 :]
+    else:
+        timeout = 30
+    return timeout, remaining
+
+
+async def _cmd_send(client: SkillClient, args: list[str]) -> dict[str, Any]:
+    channel = args[1]
+    message = " ".join(args[2:])
+    return await client.irc_send(channel, message)
+
+
+async def _cmd_read(client: SkillClient, args: list[str]) -> dict[str, Any]:
+    channel = args[1]
+    limit = int(args[2]) if len(args) > 2 else 50
+    return await client.irc_read(channel, limit=limit)
+
+
+async def _cmd_ask(client: SkillClient, args: list[str]) -> dict[str, Any]:
+    channel = args[1]
+    timeout, remaining = _parse_ask_timeout(args[2:])
+    question = " ".join(remaining)
+    return await client.irc_ask(channel, question, timeout=timeout)
+
+
+async def _cmd_join(client: SkillClient, args: list[str]) -> dict[str, Any]:
+    return await client.irc_join(args[1])
+
+
+async def _cmd_part(client: SkillClient, args: list[str]) -> dict[str, Any]:
+    return await client.irc_part(args[1])
+
+
+async def _cmd_channels(client: SkillClient, args: list[str]) -> dict[str, Any]:
+    return await client.irc_channels()
+
+
+async def _cmd_who(client: SkillClient, args: list[str]) -> dict[str, Any]:
+    return await client.irc_who(args[1])
+
+
+async def _cmd_compact(client: SkillClient, args: list[str]) -> dict[str, Any]:
+    return await client.compact()
+
+
+async def _cmd_clear(client: SkillClient, args: list[str]) -> dict[str, Any]:
+    return await client.clear()
+
+
+_SUBCOMMANDS: dict[str, Any] = {
+    "send": _cmd_send,
+    "read": _cmd_read,
+    "ask": _cmd_ask,
+    "join": _cmd_join,
+    "part": _cmd_part,
+    "channels": _cmd_channels,
+    "who": _cmd_who,
+    "compact": _cmd_compact,
+    "clear": _cmd_clear,
+}
+
+
 async def _main(args: list[str]) -> None:
     """CLI entry point. First arg is the subcommand."""
     if not args:
@@ -195,59 +279,16 @@ async def _main(args: list[str]) -> None:
     sock_path = _sock_path_from_env()
     subcommand = args[0]
 
+    handler = _SUBCOMMANDS.get(subcommand)
+    if handler is None:
+        print(f"ERROR: Unknown subcommand: {subcommand!r}", file=sys.stderr)
+        sys.exit(1)
+
     client = SkillClient(sock_path)
     await client.connect()
 
     try:
-        if subcommand == "send":
-            # send <channel> <message...>
-            channel = args[1]
-            message = " ".join(args[2:])
-            result = await client.irc_send(channel, message)
-
-        elif subcommand == "read":
-            # read <channel> [limit]
-            channel = args[1]
-            limit = int(args[2]) if len(args) > 2 else 50
-            result = await client.irc_read(channel, limit=limit)
-
-        elif subcommand == "ask":
-            # ask <channel> [--timeout N] <question...>
-            channel = args[1]
-            remaining = args[2:]
-            if "--timeout" in remaining:
-                idx = remaining.index("--timeout")
-                timeout = int(remaining[idx + 1])
-                remaining = remaining[:idx] + remaining[idx + 2 :]
-            else:
-                timeout = 30
-            question = " ".join(remaining)
-            result = await client.irc_ask(channel, question, timeout=timeout)
-
-        elif subcommand == "join":
-            channel = args[1]
-            result = await client.irc_join(channel)
-
-        elif subcommand == "part":
-            channel = args[1]
-            result = await client.irc_part(channel)
-
-        elif subcommand == "channels":
-            result = await client.irc_channels()
-
-        elif subcommand == "who":
-            target = args[1]
-            result = await client.irc_who(target)
-
-        elif subcommand == "compact":
-            result = await client.compact()
-
-        elif subcommand == "clear":
-            result = await client.clear()
-
-        else:
-            print(f"ERROR: Unknown subcommand: {subcommand!r}", file=sys.stderr)
-            sys.exit(1)
+        result = await handler(client, args)
 
         # Print result as JSON
         print(json.dumps(result, indent=2))

{agentirc_cli-4.3.2/culture/clients/claude → agentirc_cli-4.3.3/culture/clients/acp}/supervisor.py

@@ -117,6 +117,13 @@ def _format_window(window: list[dict[str, Any]], task: str) -> str:
     return "\n".join(lines)
 
 
+def _extract_verdict_text(response) -> str:
+    """Extract text from an SDK response message."""
+    if isinstance(response, AssistantMessage):
+        return "".join(block.text for block in response.content if isinstance(block, TextBlock))
+    return ""
+
+
 def make_sdk_evaluate_fn(
     model: str = "claude-sonnet-4-6",
     thinking: str | None = None,
@@ -137,10 +144,7 @@ def make_sdk_evaluate_fn(
         if thinking:
             opts.effort = thinking
         async for message in query(prompt=prompt, options=opts):
-            if isinstance(message, AssistantMessage):
-                for block in message.content:
-                    if isinstance(block, TextBlock):
-                        result_text += block.text
+            result_text += _extract_verdict_text(message)
         return SupervisorVerdict.parse(result_text)
 
     return evaluate

{agentirc_cli-4.3.2 → agentirc_cli-4.3.3}/culture/clients/claude/agent_runner.py

@@ -115,6 +115,18 @@ class AgentRunner:
             opts.resume = self._session_id
         return opts
 
+    def _handle_result_message(self, msg: ResultMessage) -> None:
+        """Handle a ResultMessage — track session and log errors."""
+        self._session_id = msg.session_id
+        if msg.is_error:
+            logger.warning("SDK session error: %s", msg.result)
+
+    async def _handle_assistant_message(self, msg: AssistantMessage) -> None:
+        """Handle an AssistantMessage — convert and fire callback."""
+        if self.on_message:
+            msg_dict = self._assistant_to_dict(msg)
+            await self.on_message(msg_dict)
+
     async def _run_loop(self) -> None:
         """Main session loop: run turns, process prompt queue between turns."""
         try:
@@ -132,13 +144,9 @@ class AgentRunner:
                         options=self._make_options(),
                     ):
                         if isinstance(message, ResultMessage):
-                            self._session_id = message.session_id
-                            if message.is_error:
-                                logger.warning("SDK session error: %s", message.result)
+                            self._handle_result_message(message)
                         elif isinstance(message, AssistantMessage):
-                            if self.on_message:
-                                msg_dict = self._assistant_to_dict(message)
-                                await self.on_message(msg_dict)
+                            await self._handle_assistant_message(message)
                 except Exception:
                     logger.exception("SDK session turn error")
                     if not self._stopping and self.on_exit:

{agentirc_cli-4.3.2 → agentirc_cli-4.3.3}/culture/clients/claude/skill/irc_client.py

@@ -83,14 +83,7 @@ class SkillClient:
                 msg = decode_message(line)
                 if msg is None:
                     continue
-                msg_type = msg.get("type")
-                if msg_type == MSG_TYPE_RESPONSE:
-                    req_id = msg.get("id", "")
-                    future = self._pending.pop(req_id, None)
-                    if future is not None and not future.done():
-                        future.set_result(msg)
-                elif msg_type == MSG_TYPE_WHISPER:
-                    self.pending_whispers.append(msg)
+                self._dispatch_message(msg)
         except (asyncio.IncompleteReadError, ConnectionError, OSError):
             pass
         finally:
@@ -100,6 +93,17 @@ class SkillClient:
                     future.set_exception(ConnectionError("Connection lost"))
             self._pending.clear()
 
+    def _dispatch_message(self, msg: dict[str, Any]) -> None:
+        """Route a decoded message to the appropriate handler."""
+        msg_type = msg.get("type")
+        if msg_type == MSG_TYPE_RESPONSE:
+            req_id = msg.get("id", "")
+            future = self._pending.pop(req_id, None)
+            if future is not None and not future.done():
+                future.set_result(msg)
+        elif msg_type == MSG_TYPE_WHISPER:
+            self.pending_whispers.append(msg)
+
     # ------------------------------------------------------------------
     # Request dispatch
     # ------------------------------------------------------------------
@@ -182,6 +186,86 @@ def _sock_path_from_env() -> str:
     return os.path.join(runtime_dir, f"culture-{nick}.sock")
 
 
+def _parse_ask_timeout(remaining: list[str]) -> tuple[int, list[str]]:
+    """Extract --timeout N from args, returning (timeout, filtered_args)."""
+    if "--timeout" in remaining:
+        idx = remaining.index("--timeout")
+        if idx + 1 >= len(remaining):
+            print("ERROR: --timeout requires a value", file=sys.stderr)
+            sys.exit(2)
+        try:
+            timeout = int(remaining[idx + 1])
+        except ValueError:
+            print(
+                f"ERROR: --timeout value must be an integer, got {remaining[idx + 1]!r}",
+                file=sys.stderr,
+            )
+            sys.exit(2)
+        if timeout <= 0:
+            print("ERROR: --timeout must be positive", file=sys.stderr)
+            sys.exit(2)
+        remaining = remaining[:idx] + remaining[idx + 2 :]
+    else:
+        timeout = 30
+    return timeout, remaining
+
+
+async def _cmd_send(client: SkillClient, args: list[str]) -> dict[str, Any]:
+    channel = args[1]
+    message = " ".join(args[2:])
+    return await client.irc_send(channel, message)
+
+
+async def _cmd_read(client: SkillClient, args: list[str]) -> dict[str, Any]:
+    channel = args[1]
+    limit = int(args[2]) if len(args) > 2 else 50
+    return await client.irc_read(channel, limit=limit)
+
+
+async def _cmd_ask(client: SkillClient, args: list[str]) -> dict[str, Any]:
+    channel = args[1]
+    timeout, remaining = _parse_ask_timeout(args[2:])
+    question = " ".join(remaining)
+    return await client.irc_ask(channel, question, timeout=timeout)
+
+
+async def _cmd_join(client: SkillClient, args: list[str]) -> dict[str, Any]:
+    return await client.irc_join(args[1])
+
+
+async def _cmd_part(client: SkillClient, args: list[str]) -> dict[str, Any]:
+    return await client.irc_part(args[1])
+
+
+async def _cmd_channels(client: SkillClient, args: list[str]) -> dict[str, Any]:
+    return await client.irc_channels()
+
+
+async def _cmd_who(client: SkillClient, args: list[str]) -> dict[str, Any]:
+    return await client.irc_who(args[1])
+
+
+async def _cmd_compact(client: SkillClient, args: list[str]) -> dict[str, Any]:
+    return await client.compact()
+
+
+async def _cmd_clear(client: SkillClient, args: list[str]) -> dict[str, Any]:
+    return await client.clear()
+
+
+_SUBCOMMANDS: dict[str, Any] = {
+    "send": _cmd_send,
+    "read": _cmd_read,
+    "ask": _cmd_ask,
+    "join": _cmd_join,
+    "part": _cmd_part,
+    "channels": _cmd_channels,
+    "who": _cmd_who,
+    "compact": _cmd_compact,
+    "clear": _cmd_clear,
+}
+
+
 async def _main(args: list[str]) -> None:
     """CLI entry point. First arg is the subcommand."""
     if not args:
@@ -195,59 +279,16 @@ async def _main(args: list[str]) -> None:
     sock_path = _sock_path_from_env()
     subcommand = args[0]
 
+    handler = _SUBCOMMANDS.get(subcommand)
+    if handler is None:
+        print(f"ERROR: Unknown subcommand: {subcommand!r}", file=sys.stderr)
+        sys.exit(1)
+
     client = SkillClient(sock_path)
     await client.connect()
 
     try:
-        if subcommand == "send":
-            # send <channel> <message...>
-            channel = args[1]
-            message = " ".join(args[2:])
-            result = await client.irc_send(channel, message)
-
-        elif subcommand == "read":
-            # read <channel> [limit]
-            channel = args[1]
-            limit = int(args[2]) if len(args) > 2 else 50
-            result = await client.irc_read(channel, limit=limit)
-
-        elif subcommand == "ask":
-            # ask <channel> [--timeout N] <question...>
-            channel = args[1]
-            remaining = args[2:]
-            if "--timeout" in remaining:
-                idx = remaining.index("--timeout")
-                timeout = int(remaining[idx + 1])
-                remaining = remaining[:idx] + remaining[idx + 2 :]
-            else:
-                timeout = 30
-            question = " ".join(remaining)
-            result = await client.irc_ask(channel, question, timeout=timeout)
-
-        elif subcommand == "join":
-            channel = args[1]
-            result = await client.irc_join(channel)
-
-        elif subcommand == "part":
-            channel = args[1]
-            result = await client.irc_part(channel)
-
-        elif subcommand == "channels":
-            result = await client.irc_channels()
-
-        elif subcommand == "who":
-            target = args[1]
-            result = await client.irc_who(target)
-
-        elif subcommand == "compact":
-            result = await client.compact()
-
-        elif subcommand == "clear":
-            result = await client.clear()
-
-        else:
-            print(f"ERROR: Unknown subcommand: {subcommand!r}", file=sys.stderr)
-            sys.exit(1)
+        result = await handler(client, args)
 
         # Print result as JSON
         print(json.dumps(result, indent=2))

{agentirc_cli-4.3.2/culture/clients/acp → agentirc_cli-4.3.3/culture/clients/claude}/supervisor.py

@@ -117,6 +117,13 @@ def _format_window(window: list[dict[str, Any]], task: str) -> str:
     return "\n".join(lines)
 
 
+def _extract_verdict_text(response) -> str:
+    """Extract text from an SDK response message."""
+    if isinstance(response, AssistantMessage):
+        return "".join(block.text for block in response.content if isinstance(block, TextBlock))
+    return ""
+
+
 def make_sdk_evaluate_fn(
     model: str = "claude-sonnet-4-6",
     thinking: str | None = None,
@@ -137,10 +144,7 @@ def make_sdk_evaluate_fn(
         if thinking:
             opts.effort = thinking
         async for message in query(prompt=prompt, options=opts):
-            if isinstance(message, AssistantMessage):
-                for block in message.content:
-                    if isinstance(block, TextBlock):
-                        result_text += block.text
+            result_text += _extract_verdict_text(message)
         return SupervisorVerdict.parse(result_text)
 
     return evaluate