open-swarm 0.1.1744943015__py3-none-any.whl → 0.1.1744947037__py3-none-any.whl

swarm/core/build_launchers.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+import PyInstaller.__main__
+
+def build_executable(script, output_name):
+    PyInstaller.__main__.run([
+        script,
+        "--onefile",
+        "--name", output_name,
+        "--add-data", "swarm_config.json:."  # Adjust if additional data is needed
+    ])
+
+if __name__ == "__main__":
+    build_executable("launchers/swarm_cli.py", "swarm-cli")
+    build_executable("launchers/swarm_rest.py", "swarm-rest")

swarm/core/build_swarm_wrapper.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+import PyInstaller.__main__
+
+PyInstaller.__main__.run([
+    "swarm_wrapper.py",
+    "--onefile",
+    "--name", "swarm-wrapper",
+    "--distpath", "~/bin",
+    "--workpath", "build",
+    "--specpath", "."
+])
+

swarm/core/common_utils.py

@@ -0,0 +1,12 @@
+"""
+Common utilities potentially shared across blueprint extensions.
+"""
+
+from typing import Any # Removed Dict, List as they weren't used
+
+def get_agent_name(agent: Any) -> str:
+    """Return the name of an agent from its attributes ('name' or '__name__')."""
+    return getattr(agent, "name", getattr(agent, "__name__", "<unknown>"))
+
+# get_token_count has been moved to swarm.utils.context_utils
+# Ensure imports in other files point to the correct location.

swarm/core/config_loader.py

@@ -0,0 +1,122 @@
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+
+from dotenv import load_dotenv
+
+logger = logging.getLogger("swarm.config")
+
+def _substitute_env_vars(value: Any) -> Any:
+    """Recursively substitute environment variables in strings, lists, and dicts."""
+    if isinstance(value, str):
+        return os.path.expandvars(value)
+    elif isinstance(value, list):
+        return [_substitute_env_vars(item) for item in value]
+    elif isinstance(value, dict):
+        return {k: _substitute_env_vars(v) for k, v in value.items()}
+    else:
+        return value
+
+def load_environment(project_root: Path):
+    """Loads environment variables from a `.env` file located at the project root."""
+    dotenv_path = project_root / ".env"
+    logger.debug(f"Checking for .env file at: {dotenv_path}")
+    try:
+        if dotenv_path.is_file():
+            loaded = load_dotenv(dotenv_path=dotenv_path, override=True)
+            if loaded:
+                logger.debug(f".env file Loaded/Overridden at: {dotenv_path}")
+        else:
+            logger.debug(f"No .env file found at {dotenv_path}.")
+    except Exception as e:
+        logger.error(f"Error loading .env file '{dotenv_path}': {e}", exc_info=logger.level <= logging.DEBUG)
+
+def load_full_configuration(
+    blueprint_class_name: str,
+    default_config_path: Path,
+    config_path_override: Optional[Union[str, Path]] = None,
+    profile_override: Optional[str] = None,
+    cli_config_overrides: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    """
+    Loads and merges configuration settings from base file, blueprint specifics, profiles, and CLI overrides.
+
+    Args:
+        blueprint_class_name (str): The name of the blueprint class (e.g., "MyBlueprint").
+        default_config_path (Path): The default path to the swarm_config.json file.
+        config_path_override (Optional[Union[str, Path]]): Path specified via CLI argument.
+        profile_override (Optional[str]): Profile specified via CLI argument.
+        cli_config_overrides (Optional[Dict[str, Any]]): Overrides provided via CLI argument.
+
+    Returns:
+        Dict[str, Any]: The final, merged configuration dictionary.
+
+    Raises:
+        ValueError: If the configuration file has JSON errors or cannot be read.
+        FileNotFoundError: If a specific config_path_override is given but the file doesn't exist.
+    """
+    config_path = Path(config_path_override) if config_path_override else default_config_path
+    logger.debug(f"Attempting to load base configuration from: {config_path}")
+    base_config = {}
+    if config_path.is_file():
+        try:
+            with open(config_path, "r", encoding="utf-8") as f:
+                base_config = json.load(f)
+            logger.debug(f"Successfully loaded base configuration from: {config_path}")
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Config Error: Failed to parse JSON in {config_path}: {e}") from e
+        except Exception as e:
+            raise ValueError(f"Config Error: Failed to read {config_path}: {e}") from e
+    else:
+        if config_path_override:
+            raise FileNotFoundError(f"Configuration Error: Specified config file not found: {config_path}")
+        else:
+            logger.warning(f"Default configuration file not found at {config_path}. Proceeding without base configuration.")
+
+    # 1. Start with base defaults
+    final_config = base_config.get("defaults", {}).copy()
+    logger.debug(f"Applied base defaults. Keys: {list(final_config.keys())}")
+
+    # 2. Merge base llm and mcpServers sections
+    if "llm" in base_config:
+        final_config.setdefault("llm", {}).update(base_config["llm"])
+        logger.debug("Merged base 'llm'.")
+    if "mcpServers" in base_config:
+        final_config.setdefault("mcpServers", {}).update(base_config["mcpServers"])
+        logger.debug("Merged base 'mcpServers'.")
+
+    # 3. Merge blueprint-specific settings
+    blueprint_settings = base_config.get("blueprints", {}).get(blueprint_class_name, {})
+    if blueprint_settings:
+        final_config.update(blueprint_settings)
+        logger.debug(f"Merged BP '{blueprint_class_name}' settings. Keys: {list(blueprint_settings.keys())}")
+
+    # 4. Determine and merge profile settings
+    # Priority: CLI > Blueprint Specific > Base Defaults > "default"
+    profile_in_bp_settings = blueprint_settings.get("default_profile")
+    profile_in_base_defaults = base_config.get("defaults", {}).get("default_profile")
+    profile_to_use = profile_override or profile_in_bp_settings or profile_in_base_defaults or "default"
+    logger.debug(f"Using profile: '{profile_to_use}'")
+    profile_settings = base_config.get("profiles", {}).get(profile_to_use, {})
+    if profile_settings:
+        final_config.update(profile_settings)
+        logger.debug(f"Merged profile '{profile_to_use}'. Keys: {list(profile_settings.keys())}")
+    elif profile_to_use != "default" and (profile_override or profile_in_bp_settings or profile_in_base_defaults):
+        logger.warning(f"Profile '{profile_to_use}' requested but not found.")
+
+    # 5. Merge CLI overrides (highest priority)
+    if cli_config_overrides:
+        final_config.update(cli_config_overrides)
+        logger.debug(f"Merged CLI overrides. Keys: {list(cli_config_overrides.keys())}")
+
+    # Ensure top-level keys exist
+    final_config.setdefault("llm", {})
+    final_config.setdefault("mcpServers", {})
+
+    # 6. Substitute environment variables in the final config
+    final_config = _substitute_env_vars(final_config)
+    logger.debug("Applied final env var substitution.")
+
+    return final_config

swarm/core/config_manager.py

@@ -0,0 +1,274 @@
+# src/swarm/extensions/config/config_manager.py
+
+import json
+import shutil
+import sys
+import logging
+from typing import Any, Dict
+
+from swarm.core.server_config import load_server_config, save_server_config
+from swarm.utils.color_utils import color_text
+from swarm.settings import DEBUG
+from swarm.core.utils.logger import *
+from swarm.extensions.cli.utils import (
+    prompt_user,
+    log_and_exit,
+    display_message
+)
+
+# Initialize logger for this module
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.DEBUG if DEBUG else logging.INFO)
+if not logger.handlers:
+    stream_handler = logging.StreamHandler()
+    formatter = logging.Formatter("[%(levelname)s] %(asctime)s - %(name)s - %(message)s")
+    stream_handler.setFormatter(formatter)
+    logger.addHandler(stream_handler)
+
+CONFIG_BACKUP_SUFFIX = ".backup"
+
+def resolve_placeholders(config):
+    # Recursively resolve placeholders in the config dict (env vars, etc.)
+    import os
+    import re
+    pattern = re.compile(r'\$\{([^}]+)\}')
+    def _resolve(val):
+        if isinstance(val, str):
+            def replacer(match):
+                var = match.group(1)
+                return os.environ.get(var, match.group(0))
+            return pattern.sub(replacer, val)
+        elif isinstance(val, dict):
+            return {k: _resolve(v) for k, v in val.items()}
+        elif isinstance(val, list):
+            return [_resolve(v) for v in val]
+        return val
+    return _resolve(config)
+
+def backup_configuration(config_path: str) -> None:
+    """
+    Create a backup of the existing configuration file.
+
+    Args:
+        config_path (str): Path to the configuration file.
+    """
+    backup_path = config_path + CONFIG_BACKUP_SUFFIX
+    try:
+        shutil.copy(config_path, backup_path)
+        logger.info(f"Configuration backup created at '{backup_path}'")
+        display_message(f"Backup of configuration created at '{backup_path}'", "info")
+    except Exception as e:
+        logger.error(f"Failed to create configuration backup: {e}")
+        display_message(f"Failed to create backup: {e}", "error")
+        sys.exit(1)
+
+def load_config(config_path: str) -> Dict[str, Any]:
+    """
+    Load the server configuration from a JSON file and resolve placeholders.
+
+    Args:
+        config_path (str): Path to the configuration file.
+
+    Returns:
+        Dict[str, Any]: The resolved configuration.
+
+    Raises:
+        FileNotFoundError: If the configuration file does not exist.
+        ValueError: If the file contains invalid JSON or unresolved placeholders.
+    """
+    try:
+        with open(config_path, "r") as file:
+            config = json.load(file)
+            logger.debug(f"Raw configuration loaded: {config}")
+    except FileNotFoundError:
+        logger.error(f"Configuration file not found at {config_path}")
+        display_message(f"Configuration file not found at {config_path}", "error")
+        sys.exit(1)
+    except json.JSONDecodeError as e:
+        logger.error(f"Invalid JSON in configuration file {config_path}: {e}")
+        display_message(f"Invalid JSON in configuration file {config_path}: {e}", "error")
+        sys.exit(1)
+
+    # Resolve placeholders recursively
+    try:
+        resolved_config = resolve_placeholders(config)
+        logger.debug(f"Configuration after resolving placeholders: {resolved_config}")
+    except Exception as e:
+        logger.error(f"Failed to resolve placeholders in configuration: {e}")
+        display_message(f"Failed to resolve placeholders in configuration: {e}", "error")
+        sys.exit(1)
+
+    return resolved_config
+
+def save_config(config_path: str, config: Dict[str, Any]) -> None:
+    """
+    Save the updated configuration to the config file.
+
+    Args:
+        config_path (str): Path to the configuration file.
+        config (Dict[str, Any]): Configuration dictionary to save.
+
+    Raises:
+        SystemExit: If saving the configuration fails.
+    """
+    try:
+        with open(config_path, "w") as f:
+            json.dump(config, f, indent=4)
+        logger.info(f"Configuration saved to '{config_path}'")
+        display_message(f"Configuration saved to '{config_path}'", "info")
+    except Exception as e:
+        logger.error(f"Failed to save configuration: {e}")
+        display_message(f"Failed to save configuration: {e}", "error")
+        sys.exit(1)
+
+def add_llm(config_path: str) -> None:
+    """
+    Add a new LLM to the configuration.
+
+    Args:
+        config_path (str): Path to the configuration file.
+    """
+    config = load_config(config_path)
+    display_message("Starting the process to add a new LLM.", "info")
+
+    while True:
+        llm_name = prompt_user("Enter the name of the new LLM (or type 'done' to finish)").strip()
+        display_message(f"User entered LLM name: {llm_name}", "info")
+        if llm_name.lower() == 'done':
+            display_message("Finished adding LLMs.", "info")
+            break
+        if not llm_name:
+            display_message("LLM name cannot be empty.", "error")
+            continue
+
+        if llm_name in config.get("llm", {}):
+            display_message(f"LLM '{llm_name}' already exists.", "warning")
+            continue
+
+        llm = {}
+        llm["provider"] = prompt_user("Enter the provider type (e.g., 'openai', 'ollama')").strip()
+        llm["model"] = prompt_user("Enter the model name (e.g., 'gpt-4')").strip()
+        llm["base_url"] = prompt_user("Enter the base URL for the API").strip()
+        llm_api_key_input = prompt_user("Enter the environment variable for the API key (e.g., 'OPENAI_API_KEY') or leave empty if not required").strip()
+        if llm_api_key_input:
+            llm["api_key"] = f"${{{llm_api_key_input}}}"
+        else:
+            llm["api_key"] = ""
+        try:
+            temperature_input = prompt_user("Enter the temperature (e.g., 0.7)").strip()
+            llm["temperature"] = float(temperature_input)
+        except ValueError:
+            display_message("Invalid temperature value. Using default 0.7.", "warning")
+            llm["temperature"] = 0.7
+
+        config.setdefault("llm", {})[llm_name] = llm
+        logger.info(f"Added LLM '{llm_name}' to configuration.")
+        display_message(f"LLM '{llm_name}' added.", "info")
+
+    backup_configuration(config_path)
+    save_config(config_path, config)
+    display_message("LLM configuration process completed.", "info")
+
+def remove_llm(config_path: str, llm_name: str) -> None:
+    """
+    Remove an existing LLM from the configuration.
+
+    Args:
+        config_path (str): Path to the configuration file.
+        llm_name (str): Name of the LLM to remove.
+    """
+    config = load_config(config_path)
+
+    if llm_name not in config.get("llm", {}):
+        display_message(f"LLM '{llm_name}' does not exist.", "error")
+        return
+
+    confirm = prompt_user(f"Are you sure you want to remove LLM '{llm_name}'? (yes/no)").strip().lower()
+    if confirm not in ['yes', 'y']:
+        display_message("Operation cancelled.", "warning")
+        return
+
+    del config["llm"][llm_name]
+    backup_configuration(config_path)
+    save_config(config_path, config)
+    display_message(f"LLM '{llm_name}' has been removed.", "info")
+    logger.info(f"Removed LLM '{llm_name}' from configuration.")
+
+def add_mcp_server(config_path: str) -> None:
+    """
+    Add a new MCP server to the configuration.
+
+    Args:
+        config_path (str): Path to the configuration file.
+    """
+    config = load_config(config_path)
+    display_message("Starting the process to add a new MCP server.", "info")
+
+    while True:
+        server_name = prompt_user("Enter the name of the new MCP server (or type 'done' to finish)").strip()
+        display_message(f"User entered MCP server name: {server_name}", "info")
+        if server_name.lower() == 'done':
+            display_message("Finished adding MCP servers.", "info")
+            break
+        if not server_name:
+            display_message("Server name cannot be empty.", "error")
+            continue
+
+        if server_name in config.get("mcpServers", {}):
+            display_message(f"MCP server '{server_name}' already exists.", "warning")
+            continue
+
+        server = {}
+        server["command"] = prompt_user("Enter the command to run the MCP server (e.g., 'npx', 'uvx')").strip()
+        args_input = prompt_user("Enter the arguments as a JSON array (e.g., [\"-y\", \"server-name\"])").strip()
+        try:
+            server["args"] = json.loads(args_input)
+            if not isinstance(server["args"], list):
+                raise ValueError
+        except ValueError:
+            display_message("Invalid arguments format. Using an empty list.", "warning")
+            server["args"] = []
+
+        env_vars = {}
+        add_env = prompt_user("Do you want to add environment variables? (yes/no)").strip().lower()
+        while add_env in ['yes', 'y']:
+            env_var = prompt_user("Enter the environment variable name").strip()
+            env_value = prompt_user(f"Enter the value or placeholder for '{env_var}' (e.g., '${{{env_var}_KEY}}')").strip()
+            if env_var and env_value:
+                env_vars[env_var] = env_value
+            add_env = prompt_user("Add another environment variable? (yes/no)").strip().lower()
+
+        server["env"] = env_vars
+
+        config.setdefault("mcpServers", {})[server_name] = server
+        logger.info(f"Added MCP server '{server_name}' to configuration.")
+        display_message(f"MCP server '{server_name}' added.", "info")
+
+    backup_configuration(config_path)
+    save_config(config_path, config)
+    display_message("MCP server configuration process completed.", "info")
+
+def remove_mcp_server(config_path: str, server_name: str) -> None:
+    """
+    Remove an existing MCP server from the configuration.
+
+    Args:
+        config_path (str): Path to the configuration file.
+        server_name (str): Name of the MCP server to remove.
+    """
+    config = load_config(config_path)
+
+    if server_name not in config.get("mcpServers", {}):
+        display_message(f"MCP server '{server_name}' does not exist.", "error")
+        return
+
+    confirm = prompt_user(f"Are you sure you want to remove MCP server '{server_name}'? (yes/no)").strip().lower()
+    if confirm not in ['yes', 'y']:
+        display_message("Operation cancelled.", "warning")
+        return
+
+    del config["mcpServers"][server_name]
+    backup_configuration(config_path)
+    save_config(config_path, config)
+    display_message(f"MCP server '{server_name}' has been removed.", "info")
+    logger.info(f"Removed MCP server '{server_name}' from configuration.")

swarm/core/output_utils.py

@@ -0,0 +1,173 @@
+"""
+Output utilities for Swarm blueprints.
+"""
+
+import json
+import logging
+import os
+import sys
+from typing import List, Dict, Any
+
+# Optional import for markdown rendering
+try:
+    from rich.markdown import Markdown
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.text import Text
+    from rich.rule import Rule
+    RICH_AVAILABLE = True
+except ImportError:
+    RICH_AVAILABLE = False
+
+logger = logging.getLogger(__name__)
+
+def render_markdown(content: str) -> None:
+    """Render markdown content using rich, if available."""
+    # --- DEBUG PRINT ---
+    print(f"\n[DEBUG render_markdown called with rich={RICH_AVAILABLE}]", flush=True)
+    if not RICH_AVAILABLE:
+        print(content, flush=True) # Fallback print with flush
+        return
+    console = Console()
+    md = Markdown(content)
+    console.print(md) # Rich handles flushing
+
+def ansi_box(title: str, content: str, color: str = "94", emoji: str = "🔎", border: str = "─", width: int = 70) -> str:
+    """Return a string or Panel with ANSI box formatting for search/analysis results using Rich if available."""
+    if RICH_AVAILABLE:
+        console = Console()
+        # Rich supports color names or hex, map color code to name
+        color_map = {
+            "94": "bright_blue",
+            "96": "bright_cyan",
+            "92": "bright_green",
+            "93": "bright_yellow",
+            "91": "bright_red",
+            "95": "bright_magenta",
+            "90": "grey82",
+        }
+        style = color_map.get(color, "bright_blue")
+        panel = Panel(
+            content,
+            title=f"{emoji} {title} {emoji}",
+            border_style=style,
+            width=width
+        )
+        # Return the rendered panel as a string for testability
+        with console.capture() as capture:
+            console.print(panel)
+        return capture.get()
+    # Fallback: legacy manual ANSI box
+    top = f"\033[{color}m{emoji} {border * (width - 4)} {emoji}\033[0m"
+    mid_title = f"\033[{color}m│ {title.center(width - 6)} │\033[0m"
+    lines = content.splitlines()
+    boxed = [top, mid_title, top]
+    for line in lines:
+        boxed.append(f"\033[{color}m│\033[0m {line.ljust(width - 6)} \033[{color}m│\033[0m")
+    boxed.append(top)
+    return "\n".join(boxed)
+
+def print_search_box(title: str, content: str, color: str = "94", emoji: str = "🔎"):
+    print(ansi_box(title, content, color=color, emoji=emoji))
+
+def pretty_print_response(messages: List[Dict[str, Any]], use_markdown: bool = False, spinner=None) -> None:
+    """Format and print messages, optionally rendering assistant content as markdown."""
+    # --- DEBUG PRINT ---
+    print(f"\n[DEBUG pretty_print_response called with {len(messages)} messages, use_markdown={use_markdown}]", flush=True)
+
+    if spinner:
+        spinner.stop()
+        sys.stdout.write("\r\033[K") # Clear spinner line
+        sys.stdout.flush()
+
+    if not messages:
+        logger.debug("No messages to print in pretty_print_response.")
+        return
+
+    for i, msg in enumerate(messages):
+         # --- DEBUG PRINT ---
+        print(f"\n[DEBUG Processing message {i}: type={type(msg)}]", flush=True)
+        if not isinstance(msg, dict):
+            print(f"[DEBUG Skipping non-dict message {i}]", flush=True)
+            continue
+
+        role = msg.get("role")
+        sender = msg.get("sender", role if role else "Unknown")
+        msg_content = msg.get("content")
+        tool_calls = msg.get("tool_calls")
+        # --- DEBUG PRINT ---
+        print(f"[DEBUG Message {i}: role={role}, sender={sender}, has_content={bool(msg_content)}, has_tools={bool(tool_calls)}]", flush=True)
+
+
+        if role == "assistant":
+            print(f"\033[94m{sender}\033[0m: ", end="", flush=True)
+            if msg_content:
+                 # --- DEBUG PRINT ---
+                print(f"\n[DEBUG Assistant content found, printing/rendering... Rich={RICH_AVAILABLE}, Markdown={use_markdown}]", flush=True)
+                if use_markdown and RICH_AVAILABLE:
+                    render_markdown(msg_content)
+                else:
+                    # --- DEBUG PRINT ---
+                    print(f"\n[DEBUG Using standard print for content:]", flush=True)
+                    print(msg_content, flush=True) # Added flush
+            elif not tool_calls:
+                print(flush=True) # Flush newline if no content/tools
+
+            if tool_calls and isinstance(tool_calls, list):
+                print("  \033[92mTool Calls:\033[0m", flush=True)
+                for tc in tool_calls:
+                    if not isinstance(tc, dict): continue
+                    func = tc.get("function", {})
+                    tool_name = func.get("name", "Unnamed Tool")
+                    args_str = func.get("arguments", "{}")
+                    try: args_obj = json.loads(args_str); args_pretty = ", ".join(f"{k}={v!r}" for k, v in args_obj.items())
+                    except json.JSONDecodeError: args_pretty = args_str
+                    print(f"    \033[95m{tool_name}\033[0m({args_pretty})", flush=True)
+
+        elif role == "tool":
+            tool_name = msg.get("tool_name", msg.get("name", "tool"))
+            tool_id = msg.get("tool_call_id", "N/A")
+            try: content_obj = json.loads(msg_content); pretty_content = json.dumps(content_obj, indent=2)
+            except (json.JSONDecodeError, TypeError): pretty_content = msg_content
+            print(f"  \033[93m[{tool_name} Result ID: {tool_id}]\033[0m:\n    {pretty_content.replace(chr(10), chr(10) + '    ')}", flush=True)
+        else:
+            # --- DEBUG PRINT ---
+            print(f"[DEBUG Skipping message {i} with role '{role}']", flush=True)
+
+def print_terminal_command_result(cmd: str, result: dict, max_lines: int = 10):
+    """
+    Render a terminal command result in the CLI with a shell prompt emoji, header, and Rich box.
+    - Header: 🐚 Ran terminal command
+    - Top line: colored, [basename(pwd)] > [cmd]
+    - Output: Rich Panel, max 10 lines, tailing if longer, show hint for toggle
+    """
+    if not RICH_AVAILABLE:
+        # Fallback to simple print
+        print(f"🐚 Ran terminal command\n[{os.path.basename(result['cwd'])}] > {cmd}")
+        lines = result['output'].splitlines()
+        if len(lines) > max_lines:
+            lines = lines[-max_lines:]
+            print("[Output truncated. Showing last 10 lines.]")
+        print("\n".join(lines))
+        return
+
+    console = Console()
+    cwd_base = os.path.basename(result['cwd'])
+    header = Text(f"🐚 Ran terminal command", style="bold yellow")
+    subheader = Rule(f"[{cwd_base}] > {cmd}", style="bright_black")
+    lines = result['output'].splitlines()
+    truncated = False
+    if len(lines) > max_lines:
+        lines = lines[-max_lines:]
+        truncated = True
+    output_body = "\n".join(lines)
+    panel = Panel(
+        output_body,
+        title="Output",
+        border_style="cyan",
+        subtitle="[Output truncated. Showing last 10 lines. Press [t] to expand.]" if truncated else "",
+        width=80
+    )
+    console.print(header)
+    console.print(subheader)
+    console.print(panel)