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

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

@@ -4,6 +4,21 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [4.3.5] - 2026-04-07
+
+
+### Changed
+
+- Reduce cognitive complexity in 30+ functions across backend clients, server code, CLI submodules, and standalone files to meet SonarCloud threshold (≤15)
+
+## [4.3.4] - 2026-04-07
+
+
+### Changed
+
+- Extract duplicated string literals into named constants (SonarCloud S1192)
+- Refactor cli/_helpers.py into modular cli/shared/ package (constants, ipc, process, mesh, display)
+
 ## [4.3.3] - 2026-04-07
 
 

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

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

{agentirc_cli-4.3.3 → agentirc_cli-4.3.5}/culture/bots/bot_manager.py

@@ -13,6 +13,8 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+BOT_CONFIG_FILE = "bot.yaml"
+
 
 class BotManager:
     """Loads, starts, stops, and dispatches webhooks to bots."""
@@ -27,7 +29,7 @@ class BotManager:
             return
 
         for bot_dir in sorted(BOTS_DIR.iterdir()):
-            yaml_path = bot_dir / "bot.yaml"
+            yaml_path = bot_dir / BOT_CONFIG_FILE
             if not yaml_path.is_file():
                 continue
             try:
@@ -45,7 +47,7 @@ class BotManager:
     async def create_bot(self, config: BotConfig) -> Bot:
         """Create a new bot: write config to disk and start it."""
         bot_dir = BOTS_DIR / config.name
-        save_bot_config(bot_dir / "bot.yaml", config)
+        save_bot_config(bot_dir / BOT_CONFIG_FILE, config)
 
         bot = Bot(config, self.server)
         self.bots[config.name] = bot
@@ -57,7 +59,7 @@ class BotManager:
         bot = self.bots.get(name)
         if not bot:
             # Try loading from disk
-            yaml_path = BOTS_DIR / name / "bot.yaml"
+            yaml_path = BOTS_DIR / name / BOT_CONFIG_FILE
             if not yaml_path.is_file():
                 raise ValueError(f"Bot {name!r} not found")
             config = load_bot_config(yaml_path)

{agentirc_cli-4.3.3 → agentirc_cli-4.3.5}/culture/cli/agent.py

@@ -27,18 +27,16 @@ from culture.pidfile import (
     write_pid,
 )
 
-from ._helpers import (
+from .shared.constants import (
     _CONFIG_HELP,
+    DEFAULT_CHANNEL,
     DEFAULT_CONFIG,
     LOG_DIR,
-    agent_socket_path,
-    get_observer,
-    ipc_request,
-    print_agent_detail,
-    print_agents_overview,
-    print_bot_listing,
-    stop_agent,
+    NO_AGENTS_MSG,
 )
+from .shared.display import print_agent_detail, print_agents_overview, print_bot_listing
+from .shared.ipc import agent_socket_path, get_observer, ipc_request
+from .shared.process import stop_agent
 
 logger = logging.getLogger("culture")
 
@@ -203,59 +201,83 @@ def dispatch(args: argparse.Namespace) -> None:
 # -----------------------------------------------------------------------
 
 
-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
-
-        return CodexAgentConfig(
-            nick=full_nick,
-            agent="codex",
-            directory=os.getcwd(),
-            channels=["#general"],
-        )
-    if args.agent == "copilot":
-        from culture.clients.copilot.config import AgentConfig as CopilotAgentConfig
-
-        return CopilotAgentConfig(
-            nick=full_nick,
-            agent="copilot",
-            directory=os.getcwd(),
-            channels=["#general"],
-        )
-    if args.agent == "acp":
-        import json as _json
+def _create_codex_config(full_nick: str) -> AgentConfig:
+    """Build a CodexAgentConfig."""
+    from culture.clients.codex.config import AgentConfig as CodexAgentConfig
+
+    return CodexAgentConfig(
+        nick=full_nick,
+        agent="codex",
+        directory=os.getcwd(),
+        channels=[DEFAULT_CHANNEL],
+    )
 
-        from culture.clients.acp.config import AgentConfig as ACPAgentConfig
 
-        acp_cmd = ["opencode", "acp"]
-        if args.acp_command:
-            try:
-                acp_cmd = _json.loads(args.acp_command)
-            except _json.JSONDecodeError:
-                acp_cmd = args.acp_command.split()
-        if (
-            not isinstance(acp_cmd, list)
-            or not acp_cmd
-            or not all(isinstance(s, str) for s in acp_cmd)
-        ):
-            print("Error: --acp-command must be a non-empty list of strings", file=sys.stderr)
-            sys.exit(1)
-        return ACPAgentConfig(
-            nick=full_nick,
-            agent="acp",
-            acp_command=acp_cmd,
-            directory=os.getcwd(),
-            channels=["#general"],
-        )
+def _create_copilot_config(full_nick: str) -> AgentConfig:
+    """Build a CopilotAgentConfig."""
+    from culture.clients.copilot.config import AgentConfig as CopilotAgentConfig
+
+    return CopilotAgentConfig(
+        nick=full_nick,
+        agent="copilot",
+        directory=os.getcwd(),
+        channels=[DEFAULT_CHANNEL],
+    )
+
+
+def _parse_acp_command(raw_command: str | None) -> list[str]:
+    """Parse and validate the ACP command from CLI args."""
+    import json as _json
+
+    acp_cmd = ["opencode", "acp"]
+    if raw_command:
+        try:
+            acp_cmd = _json.loads(raw_command)
+        except _json.JSONDecodeError:
+            acp_cmd = raw_command.split()
+    if not isinstance(acp_cmd, list) or not acp_cmd or not all(isinstance(s, str) for s in acp_cmd):
+        print("Error: --acp-command must be a non-empty list of strings", file=sys.stderr)
+        sys.exit(1)
+    return acp_cmd
+
+
+def _create_acp_config(full_nick: str, args: argparse.Namespace) -> AgentConfig:
+    """Build an ACPAgentConfig."""
+    from culture.clients.acp.config import AgentConfig as ACPAgentConfig
+
+    acp_cmd = _parse_acp_command(args.acp_command)
+    return ACPAgentConfig(
+        nick=full_nick,
+        agent="acp",
+        acp_command=acp_cmd,
+        directory=os.getcwd(),
+        channels=[DEFAULT_CHANNEL],
+    )
+
+
+def _create_default_config(full_nick: str, backend: str) -> AgentConfig:
+    """Build a default (claude) AgentConfig."""
     return AgentConfig(
         nick=full_nick,
-        agent=args.agent,
+        agent=backend,
         directory=os.getcwd(),
-        channels=["#general"],
+        channels=[DEFAULT_CHANNEL],
     )
 
 
+def _create_agent_config(args: argparse.Namespace, full_nick: str) -> AgentConfig:
+    """Build a backend-specific AgentConfig from CLI args."""
+    factories = {
+        "codex": lambda: _create_codex_config(full_nick),
+        "copilot": lambda: _create_copilot_config(full_nick),
+        "acp": lambda: _create_acp_config(full_nick, args),
+    }
+    factory = factories.get(args.agent)
+    if factory:
+        return factory()
+    return _create_default_config(full_nick, args.agent)
+
+
 def _cmd_create(args: argparse.Namespace) -> None:
     config = load_config_or_default(args.config)
 
@@ -365,7 +387,7 @@ def _resolve_agents_to_start(config, args) -> list:
         agents = _resolve_auto(config)
 
     if not agents:
-        print("No agents configured", file=sys.stderr)
+        print(NO_AGENTS_MSG, file=sys.stderr)
         sys.exit(1)
     return agents
 
@@ -389,6 +411,32 @@ def _probe_server_connection(host: str, port: int, server_name: str) -> None:
         sys.exit(1)
 
 
+def _start_foreground(config: DaemonConfig, agents: list[AgentConfig]) -> None:
+    """Start a single agent in the foreground."""
+    if len(agents) != 1:
+        print("--foreground requires a single agent nick, not --all", file=sys.stderr)
+        sys.exit(1)
+    agent = agents[0]
+    print(f"Starting agent {agent.nick} in foreground...")
+    asyncio.run(_run_single_agent(config, agent))
+
+
+def _start_background(config: DaemonConfig, agents: list[AgentConfig]) -> None:
+    """Start agents in background mode (fork on Unix, single on Windows)."""
+    if sys.platform == "win32":
+        if len(agents) != 1:
+            print(
+                "Multi-agent daemon mode not supported on Windows. Start agents individually.",
+                file=sys.stderr,
+            )
+            sys.exit(1)
+        agent = agents[0]
+        print(f"Starting agent {agent.nick}...")
+        asyncio.run(_run_single_agent(config, agent))
+    else:
+        _run_multi_agents(config, agents)
+
+
 def _cmd_start(args: argparse.Namespace) -> None:
     config = load_config(args.config)
 
@@ -397,86 +445,88 @@ def _cmd_start(args: argparse.Namespace) -> None:
     server_name = config.server.name
     _probe_server_connection(config.server.host, config.server.port, server_name)
 
-    foreground = getattr(args, "foreground", False)
-
-    if foreground:
-        if len(agents) != 1:
-            print("--foreground requires a single agent nick, not --all", file=sys.stderr)
-            sys.exit(1)
-        agent = agents[0]
-        print(f"Starting agent {agent.nick} in foreground...")
-        asyncio.run(_run_single_agent(config, agent))
+    if getattr(args, "foreground", False):
+        _start_foreground(config, agents)
     else:
-        if sys.platform == "win32":
-            if len(agents) == 1:
-                agent = agents[0]
-                print(f"Starting agent {agent.nick}...")
-                asyncio.run(_run_single_agent(config, agent))
-            else:
-                print(
-                    "Multi-agent daemon mode not supported on Windows. Start agents individually.",
-                    file=sys.stderr,
-                )
-                sys.exit(1)
-        else:
-            _run_multi_agents(config, agents)
+        _start_background(config, agents)
+
+
+def _make_backend_config(config: DaemonConfig, backend_daemon_config_cls):
+    """Build a backend-specific DaemonConfig from the base config."""
+    return backend_daemon_config_cls(
+        server=config.server,
+        webhooks=config.webhooks,
+        buffer_size=config.buffer_size,
+        agents=config.agents,
+    )
+
+
+def _create_codex_daemon(config: DaemonConfig, agent: AgentConfig):
+    """Create a Codex backend daemon."""
+    from culture.clients.codex.config import DaemonConfig as CodexDaemonConfig
+    from culture.clients.codex.daemon import CodexDaemon
+
+    return CodexDaemon(_make_backend_config(config, CodexDaemonConfig), agent)
+
+
+def _coerce_to_acp_agent(agent: AgentConfig):
+    """Ensure agent is an ACPAgentConfig, converting if necessary."""
+    from culture.clients.acp.config import AgentConfig as ACPAgentConfig
+
+    if isinstance(agent, ACPAgentConfig):
+        return agent
+    return ACPAgentConfig(
+        nick=agent.nick,
+        agent="acp",
+        acp_command=getattr(agent, "acp_command", None) or ["opencode", "acp"],
+        directory=agent.directory,
+        channels=agent.channels,
+        model=agent.model,
+        system_prompt=agent.system_prompt,
+        tags=agent.tags,
+    )
+
+
+def _create_acp_daemon(config: DaemonConfig, agent: AgentConfig):
+    """Create an ACP backend daemon."""
+    from culture.clients.acp.config import DaemonConfig as ACPDaemonConfig
+    from culture.clients.acp.daemon import ACPDaemon
+
+    return ACPDaemon(
+        _make_backend_config(config, ACPDaemonConfig),
+        _coerce_to_acp_agent(agent),
+    )
+
+
+def _create_copilot_daemon(config: DaemonConfig, agent: AgentConfig):
+    """Create a Copilot backend daemon."""
+    from culture.clients.copilot.config import DaemonConfig as CopilotDaemonConfig
+    from culture.clients.copilot.daemon import CopilotDaemon
+
+    return CopilotDaemon(_make_backend_config(config, CopilotDaemonConfig), agent)
+
+
+def _create_claude_daemon(config: DaemonConfig, agent: AgentConfig):
+    """Create the default Claude backend daemon."""
+    from culture.clients.claude.daemon import AgentDaemon
+
+    return AgentDaemon(config, agent)
+
+
+_BACKEND_DAEMON_FACTORIES = {
+    "codex": _create_codex_daemon,
+    "acp": _create_acp_daemon,
+    "opencode": _create_acp_daemon,
+    "copilot": _create_copilot_daemon,
+}
 
 
 async def _run_single_agent(config: DaemonConfig, agent: AgentConfig) -> None:
     """Run a single agent daemon in the foreground."""
     backend = getattr(agent, "agent", "claude")
 
-    if backend == "codex":
-        from culture.clients.codex.config import DaemonConfig as CodexDaemonConfig
-        from culture.clients.codex.daemon import CodexDaemon
-
-        codex_config = CodexDaemonConfig(
-            server=config.server,
-            webhooks=config.webhooks,
-            buffer_size=config.buffer_size,
-            agents=config.agents,
-        )
-        daemon = CodexDaemon(codex_config, agent)
-    elif backend in ("acp", "opencode"):
-        from culture.clients.acp.config import AgentConfig as ACPAgentConfig
-        from culture.clients.acp.config import DaemonConfig as ACPDaemonConfig
-        from culture.clients.acp.daemon import ACPDaemon
-
-        acp_config = ACPDaemonConfig(
-            server=config.server,
-            webhooks=config.webhooks,
-            buffer_size=config.buffer_size,
-            agents=config.agents,
-        )
-        if not isinstance(agent, ACPAgentConfig):
-            acp_agent = ACPAgentConfig(
-                nick=agent.nick,
-                agent="acp",
-                acp_command=getattr(agent, "acp_command", None) or ["opencode", "acp"],
-                directory=agent.directory,
-                channels=agent.channels,
-                model=agent.model,
-                system_prompt=agent.system_prompt,
-                tags=agent.tags,
-            )
-        else:
-            acp_agent = agent
-        daemon = ACPDaemon(acp_config, acp_agent)
-    elif backend == "copilot":
-        from culture.clients.copilot.config import DaemonConfig as CopilotDaemonConfig
-        from culture.clients.copilot.daemon import CopilotDaemon
-
-        copilot_config = CopilotDaemonConfig(
-            server=config.server,
-            webhooks=config.webhooks,
-            buffer_size=config.buffer_size,
-            agents=config.agents,
-        )
-        daemon = CopilotDaemon(copilot_config, agent)
-    else:
-        from culture.clients.claude.daemon import AgentDaemon
-
-        daemon = AgentDaemon(config, agent)
+    factory = _BACKEND_DAEMON_FACTORIES.get(backend, _create_claude_daemon)
+    daemon = factory(config, agent)
 
     stop_event = asyncio.Event()
     daemon.set_stop_event(stop_event)
@@ -526,30 +576,31 @@ def _run_multi_agents(config: DaemonConfig, agents: list[AgentConfig]) -> None:
             print(f"Started {agent.nick} (PID {pid})")
 
 
-def _cmd_stop(args: argparse.Namespace) -> None:
-    config = load_config_or_default(args.config)
-
+def _resolve_agents_to_stop(config, args) -> list:
+    """Resolve which agents should be stopped, or exit with an error."""
     if args.all:
-        agents = config.agents
-    elif args.nick:
+        return config.agents
+    if 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)
-        agents = [agent]
-    else:
-        if len(config.agents) == 1:
-            agents = config.agents
-        elif len(config.agents) == 0:
-            print("No agents configured", file=sys.stderr)
-            sys.exit(1)
-        else:
-            print(
-                "Multiple agents configured. Specify a nick or use --all.",
-                file=sys.stderr,
-            )
-            sys.exit(1)
+        return [agent]
+    if len(config.agents) == 1:
+        return config.agents
+    if len(config.agents) == 0:
+        print(NO_AGENTS_MSG, file=sys.stderr)
+        sys.exit(1)
+    print(
+        "Multiple agents configured. Specify a nick or use --all.",
+        file=sys.stderr,
+    )
+    sys.exit(1)
 
+
+def _cmd_stop(args: argparse.Namespace) -> None:
+    config = load_config_or_default(args.config)
+    agents = _resolve_agents_to_stop(config, args)
     for agent in agents:
         stop_agent(agent.nick)
 
@@ -574,14 +625,14 @@ def _no_agents_message(config, show_all: bool) -> str:
         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"
+    return NO_AGENTS_MSG
 
 
 def _cmd_status(args: argparse.Namespace) -> None:
     config = load_config_or_default(args.config)
 
     if not config.agents:
-        print("No agents configured")
+        print(NO_AGENTS_MSG)
         return
 
     if args.nick:

{agentirc_cli-4.3.3 → agentirc_cli-4.3.5}/culture/cli/bot.py

@@ -8,7 +8,7 @@ import time
 
 from culture.clients.claude.config import load_config_or_default
 
-from ._helpers import _CONFIG_HELP, DEFAULT_CONFIG
+from .shared.constants import _BOT_NAME_HELP, _CONFIG_HELP, BOT_CONFIG_FILE, DEFAULT_CONFIG
 
 NAME = "bot"
 
@@ -31,11 +31,11 @@ def register(subparsers: argparse._SubParsersAction) -> None:
     bot_create.add_argument("--config", default=DEFAULT_CONFIG, help=_CONFIG_HELP)
 
     bot_start = bot_sub.add_parser("start", help="Start a bot")
-    bot_start.add_argument("name", help="Bot name")
+    bot_start.add_argument("name", help=_BOT_NAME_HELP)
     bot_start.add_argument("--config", default=DEFAULT_CONFIG, help=_CONFIG_HELP)
 
     bot_stop = bot_sub.add_parser("stop", help="Stop a bot")
-    bot_stop.add_argument("name", help="Bot name")
+    bot_stop.add_argument("name", help=_BOT_NAME_HELP)
     bot_stop.add_argument("--config", default=DEFAULT_CONFIG, help=_CONFIG_HELP)
 
     bot_list = bot_sub.add_parser("list", help="List bots")
@@ -43,7 +43,7 @@ def register(subparsers: argparse._SubParsersAction) -> None:
     bot_list.add_argument("--all", action="store_true", help="Include archived bots")
 
     bot_inspect = bot_sub.add_parser("inspect", help="Show bot details")
-    bot_inspect.add_argument("name", help="Bot name")
+    bot_inspect.add_argument("name", help=_BOT_NAME_HELP)
     bot_inspect.add_argument("--config", default=DEFAULT_CONFIG, help=_CONFIG_HELP)
 
     bot_archive = bot_sub.add_parser("archive", help="Archive a bot")
@@ -113,11 +113,11 @@ def _bot_create(args: argparse.Namespace) -> None:
     )
 
     bot_dir = BOTS_DIR / name
-    if (bot_dir / "bot.yaml").exists():
+    if (bot_dir / BOT_CONFIG_FILE).exists():
         print(f"Bot '{name}' already exists at {bot_dir}", file=sys.stderr)
         sys.exit(1)
 
-    save_bot_config(bot_dir / "bot.yaml", bot_config)
+    save_bot_config(bot_dir / BOT_CONFIG_FILE, bot_config)
     print(f"Bot '{name}' created at {bot_dir}")
     print(f"  Owner:    {args.owner}")
     print(f"  Trigger:  {args.trigger}")
@@ -132,7 +132,7 @@ def _bot_start(args: argparse.Namespace) -> None:
     from culture.bots.config import BOTS_DIR
 
     bot_dir = BOTS_DIR / args.name
-    if not (bot_dir / "bot.yaml").exists():
+    if not (bot_dir / BOT_CONFIG_FILE).exists():
         print(f"Bot '{args.name}' not found at {bot_dir}", file=sys.stderr)
         sys.exit(1)
 
@@ -144,7 +144,7 @@ def _bot_stop(args: argparse.Namespace) -> None:
     from culture.bots.config import BOTS_DIR
 
     bot_dir = BOTS_DIR / args.name
-    if not (bot_dir / "bot.yaml").exists():
+    if not (bot_dir / BOT_CONFIG_FILE).exists():
         print(f"Bot '{args.name}' not found at {bot_dir}", file=sys.stderr)
         sys.exit(1)
 
@@ -152,6 +152,15 @@ def _bot_stop(args: argparse.Namespace) -> None:
     print("(Live reload via IPC will be available in a future release.)")
 
 
+def _should_include_bot(bot_config, owner: str | None, show_archived: bool) -> bool:
+    """Return True if the bot should be included in the listing."""
+    if owner and bot_config.owner != owner:
+        return False
+    if not show_archived and bot_config.archived:
+        return False
+    return True
+
+
 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
@@ -161,18 +170,15 @@ def _load_and_filter_bots(args) -> list:
     show_all = getattr(args, "all", False)
     bots = []
     for bot_dir in sorted(BOTS_DIR.iterdir()):
-        yaml_path = bot_dir / "bot.yaml"
+        yaml_path = bot_dir / BOT_CONFIG_FILE
         if not yaml_path.is_file():
             continue
         try:
             config = load_bot_config(yaml_path)
         except Exception:
             continue
-        if args.owner and config.owner != args.owner:
-            continue
-        if not show_all and config.archived:
-            continue
-        bots.append(config)
+        if _should_include_bot(config, args.owner, show_all):
+            bots.append(config)
     return bots
 
 
@@ -203,7 +209,7 @@ def _bot_inspect(args: argparse.Namespace) -> None:
     from culture.bots.config import BOTS_DIR, load_bot_config
 
     bot_dir = BOTS_DIR / args.name
-    yaml_path = bot_dir / "bot.yaml"
+    yaml_path = bot_dir / BOT_CONFIG_FILE
     if not yaml_path.is_file():
         print(f"Bot '{args.name}' not found at {bot_dir}", file=sys.stderr)
         sys.exit(1)
@@ -245,7 +251,7 @@ def _bot_archive(args: argparse.Namespace) -> None:
     from culture.bots.config import BOTS_DIR, load_bot_config, save_bot_config
 
     bot_dir = BOTS_DIR / args.name
-    yaml_path = bot_dir / "bot.yaml"
+    yaml_path = bot_dir / BOT_CONFIG_FILE
     if not yaml_path.is_file():
         print(f"Bot '{args.name}' not found at {bot_dir}", file=sys.stderr)
         sys.exit(1)
@@ -270,7 +276,7 @@ def _bot_unarchive(args: argparse.Namespace) -> None:
     from culture.bots.config import BOTS_DIR, load_bot_config, save_bot_config
 
     bot_dir = BOTS_DIR / args.name
-    yaml_path = bot_dir / "bot.yaml"
+    yaml_path = bot_dir / BOT_CONFIG_FILE
     if not yaml_path.is_file():
         print(f"Bot '{args.name}' not found at {bot_dir}", file=sys.stderr)
         sys.exit(1)

{agentirc_cli-4.3.3 → agentirc_cli-4.3.5}/culture/cli/channel.py

@@ -6,7 +6,8 @@ import argparse
 import asyncio
 import sys
 
-from ._helpers import _CONFIG_HELP, DEFAULT_CONFIG, get_observer
+from .shared.constants import _CONFIG_HELP, DEFAULT_CONFIG
+from .shared.ipc import get_observer
 
 NAME = "channel"