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

{agentirc_cli-4.3.1 → agentirc_cli-4.3.2}/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.2] - 2026-04-07
+
+
+### Changed
+
+- Reduced cognitive complexity in 13 functions across 6 files by extracting helpers and flattening control flow (SonarCloud S3776)
+
 ## [4.3.1] - 2026-04-07
 
 

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

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

{agentirc_cli-4.3.1 → agentirc_cli-4.3.2}/culture/cli/_helpers.py

@@ -381,6 +381,25 @@ def print_agent_detail(agent, config_path: str, args: argparse.Namespace) -> Non
     print(f"  Config:     {config_path}")
 
 
+def _format_agent_status(base_status: str, archived: bool, show_archived_marker: bool) -> str:
+    """Format the display status string for an agent."""
+    if not archived:
+        return base_status
+    if show_archived_marker:
+        return f"{base_status} (archived)"
+    if base_status == "stopped":
+        return "archived"
+    return base_status
+
+
+def _fetch_agent_activity(agent) -> str:
+    """Fetch activity description from a running agent via IPC."""
+    resp = asyncio.run(ipc_request(agent_socket_path(agent.nick), "status"))
+    if resp and resp.get("ok"):
+        return resp.get("data", {}).get("description", "nothing")
+    return "-"
+
+
 def print_agents_overview(
     agents: list, show_activity: bool, show_archived_marker: bool = False
 ) -> None:
@@ -393,44 +412,45 @@ def print_agents_overview(
         print("-" * 52)
 
     for agent in agents:
-        archived = getattr(agent, "archived", False)
         base_status, pid = agent_process_status(agent)
-        status = base_status
-        if archived:
-            if show_archived_marker:
-                status = f"{base_status} (archived)"
-            elif base_status == "stopped":
-                status = "archived"
-        activity = "-"
-
-        if show_activity and base_status == "running":
-            resp = asyncio.run(ipc_request(agent_socket_path(agent.nick), "status"))
-            if resp and resp.get("ok"):
-                activity = resp.get("data", {}).get("description", "nothing")
-
+        status = _format_agent_status(
+            base_status, getattr(agent, "archived", False), show_archived_marker
+        )
+        activity = (
+            _fetch_agent_activity(agent) if show_activity and base_status == "running" else "-"
+        )
         if show_activity:
             print(f"{agent.nick:<30} {status:<12} {str(pid or '-'):<10} {activity}")
         else:
             print(f"{agent.nick:<30} {status:<12} {str(pid or '-'):<10}")
 
 
-def print_bot_listing() -> None:
-    """Print a table of configured bots (if any exist)."""
+def _load_bot_configs() -> list:
+    """Load all valid bot configs from the bots directory."""
     from culture.bots.config import BOTS_DIR, load_bot_config
 
-    if BOTS_DIR.is_dir():
-        bot_configs = []
-        for bot_dir in sorted(BOTS_DIR.iterdir()):
-            yaml_path = bot_dir / "bot.yaml"
-            if yaml_path.is_file():
-                try:
-                    bot_configs.append(load_bot_config(yaml_path))
-                except Exception:
-                    pass
-        if bot_configs:
-            print()
-            print(f"{'BOT':<30} {'TRIGGER':<12} {'CHANNELS'}")
-            print("-" * 60)
-            for bc in bot_configs:
-                channels = ", ".join(bc.channels) if bc.channels else "-"
-                print(f"{bc.name:<30} {bc.trigger_type:<12} {channels}")
+    if not BOTS_DIR.is_dir():
+        return []
+    configs = []
+    for bot_dir in sorted(BOTS_DIR.iterdir()):
+        yaml_path = bot_dir / "bot.yaml"
+        if not yaml_path.is_file():
+            continue
+        try:
+            configs.append(load_bot_config(yaml_path))
+        except Exception:
+            pass
+    return configs
+
+
+def print_bot_listing() -> None:
+    """Print a table of configured bots (if any exist)."""
+    bot_configs = _load_bot_configs()
+    if not bot_configs:
+        return
+    print()
+    print(f"{'BOT':<30} {'TRIGGER':<12} {'CHANNELS'}")
+    print("-" * 60)
+    for bc in bot_configs:
+        channels = ", ".join(bc.channels) if bc.channels else "-"
+        print(f"{bc.name:<30} {bc.trigger_type:<12} {channels}")

{agentirc_cli-4.3.1 → agentirc_cli-4.3.2}/culture/cli/agent.py

@@ -315,52 +315,58 @@ def _cmd_join(args: argparse.Namespace) -> None:
 # -----------------------------------------------------------------------
 
 
+def _get_active_agents(config) -> list:
+    """Return non-archived agents."""
+    return [a for a in config.agents if not a.archived]
+
+
+def _resolve_by_nick(config, nick: str):
+    """Look up a single agent by nick, exit on error."""
+    agent = config.get_agent(nick)
+    if not agent:
+        print(f"Agent '{nick}' not found in config", file=sys.stderr)
+        sys.exit(1)
+    if agent.archived:
+        print(f"Agent '{nick}' is archived. Unarchive first:", file=sys.stderr)
+        print(f"  culture agent unarchive {nick}", file=sys.stderr)
+        sys.exit(1)
+    return agent
+
+
+def _resolve_auto(config) -> list:
+    """Auto-resolve agents when no nick or --all given, exit if ambiguous."""
+    active = _get_active_agents(config)
+    if len(active) == 1:
+        return active
+    if len(active) == 0:
+        archived_count = sum(1 for a in config.agents if a.archived)
+        if archived_count:
+            print(
+                f"No active agents ({archived_count} archived). "
+                "Unarchive an agent or create a new one.",
+                file=sys.stderr,
+            )
+        else:
+            print("No agents configured. Run 'culture agent create' first.", file=sys.stderr)
+        sys.exit(1)
+    print("Multiple agents configured. Specify a nick or use --all.", file=sys.stderr)
+    for a in active:
+        print(f"  {a.nick}", file=sys.stderr)
+    sys.exit(1)
+
+
 def _resolve_agents_to_start(config, args) -> list:
     """Return the list of agents to start, or exit with an error message."""
     if args.all:
-        # Skip archived agents when starting --all
-        agents = [a for a in config.agents if not a.archived]
+        agents = _get_active_agents(config)
     elif args.nick:
-        agent = config.get_agent(args.nick)
-        if not agent:
-            print(f"Agent '{args.nick}' not found in config", file=sys.stderr)
-            sys.exit(1)
-        if agent.archived:
-            print(
-                f"Agent '{args.nick}' is archived. Unarchive first:",
-                file=sys.stderr,
-            )
-            print(f"  culture agent unarchive {args.nick}", file=sys.stderr)
-            sys.exit(1)
-        agents = [agent]
+        agents = [_resolve_by_nick(config, args.nick)]
     else:
-        active = [a for a in config.agents if not a.archived]
-        if len(active) == 1:
-            agents = active
-        elif len(active) == 0:
-            archived_count = sum(1 for a in config.agents if a.archived)
-            if archived_count:
-                print(
-                    f"No active agents ({archived_count} archived). "
-                    "Unarchive an agent or create a new one.",
-                    file=sys.stderr,
-                )
-            else:
-                print("No agents configured. Run 'culture agent create' first.", file=sys.stderr)
-            sys.exit(1)
-        else:
-            print(
-                "Multiple agents configured. Specify a nick or use --all.",
-                file=sys.stderr,
-            )
-            for a in active:
-                print(f"  {a.nick}", file=sys.stderr)
-            sys.exit(1)
+        agents = _resolve_auto(config)
 
     if not agents:
         print("No agents configured", file=sys.stderr)
         sys.exit(1)
-
     return agents
 
 
@@ -553,6 +559,24 @@ def _cmd_stop(args: argparse.Namespace) -> None:
 # -----------------------------------------------------------------------
 
 
+def _print_archived_info(agent) -> None:
+    """Print archive details for an agent."""
+    if not agent.archived:
+        return
+    print(f"\n  [archived since {agent.archived_at}]")
+    if agent.archived_reason:
+        print(f"  Reason: {agent.archived_reason}")
+
+
+def _no_agents_message(config, show_all: bool) -> str:
+    """Return appropriate message when no agents to display."""
+    if not show_all:
+        archived_count = sum(1 for a in config.agents if a.archived)
+        if archived_count:
+            return f"No active agents ({archived_count} archived, use --all to show)"
+    return "No agents configured"
+
+
 def _cmd_status(args: argparse.Namespace) -> None:
     config = load_config_or_default(args.config)
 
@@ -561,34 +585,19 @@ def _cmd_status(args: argparse.Namespace) -> None:
         return
 
     if args.nick:
-        agent = None
-        for a in config.agents:
-            if a.nick == args.nick:
-                agent = a
-                break
+        agent = config.get_agent(args.nick)
         if not agent:
             print(f"Agent '{args.nick}' not found in config", file=sys.stderr)
             sys.exit(1)
-
         print_agent_detail(agent, args.config, args)
-        if agent.archived:
-            print(f"\n  [archived since {agent.archived_at}]")
-            if agent.archived_reason:
-                print(f"  Reason: {agent.archived_reason}")
+        _print_archived_info(agent)
         return
 
     show_all = getattr(args, "all", False)
-    if show_all:
-        agents = config.agents
-    else:
-        agents = [a for a in config.agents if not a.archived]
+    agents = config.agents if show_all else _get_active_agents(config)
 
-    if not agents and not show_all:
-        archived_count = sum(1 for a in config.agents if a.archived)
-        if archived_count:
-            print(f"No active agents ({archived_count} archived, use --all to show)")
-        else:
-            print("No agents configured")
+    if not agents:
+        print(_no_agents_message(config, show_all))
         return
 
     print_agents_overview(agents, args.full, show_archived_marker=show_all)
@@ -703,35 +712,39 @@ def _cmd_assign(args: argparse.Namespace) -> None:
 # -----------------------------------------------------------------------
 
 
-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)
-
+def _resolve_ipc_targets(config, args, action_verb: str) -> list:
+    """Resolve which agents to send IPC messages to."""
     if args.nick and args.all:
         print("Cannot specify both nick and --all", file=sys.stderr)
         sys.exit(1)
-
     if not args.nick and not args.all:
         print(f"Usage: culture agent {action_verb} <nick> or --all", file=sys.stderr)
         sys.exit(1)
+    if args.all:
+        return config.agents
+    for a in config.agents:
+        if a.nick == args.nick:
+            return [a]
+    print(f"Agent '{args.nick}' not found in config", 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)
 
+def _send_ipc(agent, msg_type: str, action_verb: str) -> None:
+    """Send a single IPC message to an agent and print result."""
+    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 _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)
+    targets = _resolve_ipc_targets(config, args, action_verb)
     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)
+        _send_ipc(agent, msg_type, action_verb)
 
 
 def _cmd_sleep(args: argparse.Namespace) -> None:
@@ -748,38 +761,24 @@ def _cmd_learn(args: argparse.Namespace) -> None:
     config = load_config_or_default(args.config)
     cwd = os.getcwd()
 
-    agent = None
     if args.nick:
-        for a in config.agents:
-            if a.nick == args.nick:
-                agent = a
-                break
+        agent = config.get_agent(args.nick)
         if not agent:
             print(f"Agent '{args.nick}' not found in config", file=sys.stderr)
             sys.exit(1)
     else:
-        for a in config.agents:
-            if os.path.realpath(a.directory) == os.path.realpath(cwd):
-                agent = a
-                break
+        cwd_real = os.path.realpath(cwd)
+        agent = next(
+            (a for a in config.agents if os.path.realpath(a.directory) == cwd_real),
+            None,
+        )
 
+    kwargs = {"server": config.server.name, "directory": cwd}
     if agent:
-        print(
-            generate_learn_prompt(
-                nick=agent.nick,
-                server=config.server.name,
-                directory=agent.directory,
-                backend=agent.agent,
-                channels=agent.channels,
-            )
-        )
-    else:
-        print(
-            generate_learn_prompt(
-                server=config.server.name,
-                directory=cwd,
-            )
+        kwargs.update(
+            nick=agent.nick, directory=agent.directory, backend=agent.agent, channels=agent.channels
         )
+    print(generate_learn_prompt(**kwargs))
 
 
 # -----------------------------------------------------------------------

{agentirc_cli-4.3.1 → agentirc_cli-4.3.2}/culture/cli/bot.py

@@ -152,13 +152,12 @@ def _bot_stop(args: argparse.Namespace) -> None:
     print("(Live reload via IPC will be available in a future release.)")
 
 
-def _bot_list(args: argparse.Namespace) -> None:
+def _load_and_filter_bots(args) -> list:
+    """Load bot configs, filtering by owner and archived status."""
     from culture.bots.config import BOTS_DIR, load_bot_config
 
     if not BOTS_DIR.is_dir():
-        print("No bots configured.")
-        return
-
+        return []
     show_all = getattr(args, "all", False)
     bots = []
     for bot_dir in sorted(BOTS_DIR.iterdir()):
@@ -167,14 +166,24 @@ def _bot_list(args: argparse.Namespace) -> None:
             continue
         try:
             config = load_bot_config(yaml_path)
-            if args.owner and config.owner != args.owner:
-                continue
-            if not show_all and config.archived:
-                continue
-            bots.append(config)
         except Exception:
             continue
+        if args.owner and config.owner != args.owner:
+            continue
+        if not show_all and config.archived:
+            continue
+        bots.append(config)
+    return bots
 
+
+def _bot_list(args: argparse.Namespace) -> None:
+    from culture.bots.config import BOTS_DIR
+
+    if not BOTS_DIR.is_dir():
+        print("No bots configured.")
+        return
+
+    bots = _load_and_filter_bots(args)
     if not bots:
         if args.owner:
             print(f"No bots found for owner '{args.owner}'.")
@@ -182,12 +191,11 @@ def _bot_list(args: argparse.Namespace) -> None:
             print("No bots configured.")
         return
 
+    show_all = getattr(args, "all", False)
     print(f"{'NAME':<35} {'TRIGGER':<10} {'CHANNELS':<20} {'OWNER':<20}")
     for config in bots:
         channels = ", ".join(config.channels) if config.channels else "-"
-        name = config.name
-        if show_all and config.archived:
-            name = f"{name} [archived]"
+        name = f"{config.name} [archived]" if show_all and config.archived else config.name
         print(f"{name:<35} {config.trigger_type:<10} {channels:<20} {config.owner:<20}")
 
 

{agentirc_cli-4.3.1 → agentirc_cli-4.3.2}/culture/cli/mesh.py

@@ -408,6 +408,30 @@ def _cmd_setup(args: argparse.Namespace) -> None:
 # -----------------------------------------------------------------------
 
 
+def _find_upgrade_tool() -> tuple[str, list[str]] | None:
+    """Return (tool_name, command_args) for the first available upgrade tool, or None."""
+    uv = shutil.which("uv")
+    if uv:
+        return "uv", [uv, "tool", "upgrade", "culture"]
+
+    pip = shutil.which("pip") or shutil.which("pip3")
+    if pip:
+        return "pip", [pip, "install", "--upgrade", "culture"]
+
+    return None
+
+
+def _run_upgrade(tool_name: str, cmd: list[str]) -> None:
+    """Run the upgrade subprocess and exit on failure."""
+    print(f"Upgrading via {tool_name}...")
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if tool_name == "uv":
+        print(result.stdout.strip() if result.stdout else "")
+    if result.returncode != 0:
+        print(f"{tool_name} upgrade failed: {result.stderr}", file=sys.stderr)
+        sys.exit(1)
+
+
 def _upgrade_culture_package(args: argparse.Namespace) -> bool:
     """Upgrade the culture package via uv or pip, then re-exec with --skip-upgrade."""
     if args.skip_upgrade:
@@ -418,33 +442,12 @@ def _upgrade_culture_package(args: argparse.Namespace) -> bool:
         print("[dry-run] Would re-exec with --skip-upgrade")
         return False
 
-    uv = shutil.which("uv")
-    if uv:
-        print("Upgrading via uv...")
-        result = subprocess.run(
-            [uv, "tool", "upgrade", "culture"],
-            capture_output=True,
-            text=True,
-        )
-        print(result.stdout.strip() if result.stdout else "")
-        if result.returncode != 0:
-            print(f"uv upgrade failed: {result.stderr}", file=sys.stderr)
-            sys.exit(1)
-    else:
-        pip = shutil.which("pip") or shutil.which("pip3")
-        if pip:
-            print("Upgrading via pip...")
-            result = subprocess.run(
-                [pip, "install", "--upgrade", "culture"],
-                capture_output=True,
-                text=True,
-            )
-            if result.returncode != 0:
-                print(f"pip upgrade failed: {result.stderr}", file=sys.stderr)
-                sys.exit(1)
-        else:
-            print("Neither uv nor pip found", file=sys.stderr)
-            sys.exit(1)
+    tool = _find_upgrade_tool()
+    if tool is None:
+        print("Neither uv nor pip found", file=sys.stderr)
+        sys.exit(1)
+
+    _run_upgrade(*tool)
 
     culture_bin = shutil.which("culture") or "culture"
     reexec_args = [culture_bin, "mesh", "update", "--skip-upgrade", "--config", args.config]
@@ -455,6 +458,18 @@ def _upgrade_culture_package(args: argparse.Namespace) -> bool:
         os.execvp(culture_bin, reexec_args)
 
 
+def _wait_for_server_port(port: int, retries: int = 50, interval: float = 0.1) -> None:
+    """Poll until *port* accepts a TCP connection."""
+    import socket as _socket
+
+    for _ in range(retries):
+        try:
+            with _socket.create_connection(("localhost", port), timeout=1):
+                return
+        except (ConnectionRefusedError, OSError):
+            time.sleep(interval)
+
+
 def _restart_mesh_services(
     mesh, server_name: str, culture_bin: str, config_path: str, dry_run: bool
 ) -> None:
@@ -479,7 +494,7 @@ def _restart_mesh_services(
     print(f"  Stopping server {server_name}...")
     server_stop_by_name(server_name)
 
-    from culture.persistence import install_service
+    from culture.persistence import install_service, restart_service
 
     server_cmd = build_server_start_cmd(mesh, culture_bin, config_path)
     install_service(f"culture-server-{server_name}", server_cmd, f"culture server {server_name}")
@@ -499,8 +514,6 @@ def _restart_mesh_services(
         ]
         install_service(f"culture-agent-{full_nick}", agent_cmd, f"culture agent {full_nick}")
 
-    from culture.persistence import restart_service
-
     server_svc = f"culture-server-{server_name}"
     print(f"  Restarting {server_svc}...")
     if not restart_service(server_svc):
@@ -528,14 +541,7 @@ def _restart_mesh_services(
                 check=False,
             )
 
-    import socket as _socket
-
-    for _ in range(50):
-        try:
-            with _socket.create_connection(("localhost", mesh.server.port), timeout=1):
-                break
-        except (ConnectionRefusedError, OSError):
-            time.sleep(0.1)
+    _wait_for_server_port(mesh.server.port)
 
     for agent in mesh.agents:
         full_nick = f"{server_name}-{agent.nick}"