open-swarm 0.1.1743070217__py3-none-any.whl

swarm/extensions/cli/blueprint_runner.py

@@ -0,0 +1,251 @@
+# src/swarm/extensions/blueprint/modes/cli_mode/blueprint_runner.py
+
+import importlib.util
+import os
+import sys
+import logging
+from typing import Optional, Dict, Any, List
+import asyncio
+import argparse
+
+from swarm.utils.general_utils import color_text
+
+# Initialize logger for this module
+from swarm.utils.logger_setup import setup_logger
+
+logger = setup_logger(__name__)
+
+
+def load_blueprint(blueprint_path: str) -> Any:
+    """
+    Dynamically load a blueprint module from the given file path.
+
+    Args:
+        blueprint_path (str): Path to the blueprint's Python file.
+
+    Returns:
+        Any: The loaded blueprint module.
+
+    Raises:
+        ImportError: If the module cannot be imported.
+    """
+    spec = importlib.util.spec_from_file_location("blueprint_module", blueprint_path)
+    print(f"DEBUG: Attempting to load blueprint at path: {blueprint_path}")
+    module = importlib.util.module_from_spec(spec)
+    try:
+        spec.loader.exec_module(module)  # type: ignore
+        logger.info(f"Successfully loaded blueprint from {blueprint_path}")
+    except Exception as e:
+        logger.error(f"Failed to import blueprint at {blueprint_path}: {e}")
+        raise ImportError(f"Failed to import blueprint at {blueprint_path}: {e}")
+    return module
+
+
+def run_blueprint_framework(blueprint_module: Any) -> None:
+    """
+    Runs the blueprint in framework integration mode by invoking its execute() function.
+
+    Args:
+        blueprint_module: The loaded blueprint module.
+
+    Raises:
+        AttributeError: If the blueprint does not have an execute() function.
+    """
+    if not hasattr(blueprint_module, 'execute'):
+        logger.error("The blueprint does not have an execute() function.")
+        raise AttributeError("The blueprint does not have an execute() function.")
+
+    execute_func = blueprint_module.execute
+
+    # Optionally, load configuration from environment or a config file
+    config = {}
+
+    try:
+        result = execute_func(config)
+        print("Execution Result:")
+        print("Status:", result.get("status"))
+        print("Messages:")
+        for msg in result.get("messages", []):
+            print(f"{msg.get('role')}: {msg.get('content')}")
+        print("Metadata:", result.get("metadata"))
+        logger.info(f"Blueprint executed successfully with result: {result}")
+    except Exception as e:
+        logger.error(f"Error executing blueprint: {e}")
+        print(f"Error executing blueprint: {e}")
+
+
+def run_blueprint_interactive(blueprint_module: Any) -> None:
+    """
+    Runs the blueprint in interactive standalone mode by invoking its interactive_mode() function.
+
+    Args:
+        blueprint_module: The loaded blueprint module.
+
+    Raises:
+        AttributeError: If the blueprint does not have an interactive_mode() function.
+    """
+    if not hasattr(blueprint_module, 'interactive_mode'):
+        logger.error("The blueprint does not have an interactive_mode() function.")
+        raise AttributeError("The blueprint does not have an interactive_mode() function.")
+
+    interactive_func = blueprint_module.interactive_mode
+
+    try:
+        interactive_func()
+        logger.info("Blueprint interactive mode executed successfully.")
+    except Exception as e:
+        logger.error(f"Error in interactive mode: {e}")
+        print(f"Error in interactive mode: {e}")
+
+
+async def run_blueprint_mode(
+    blueprints_to_load: List[str],
+    config: Dict[str, Any],
+    blueprints_metadata: Dict[str, Dict[str, Any]],
+    args: Any
+) -> None:
+    """
+    Executes the selected blueprints in the specified mode.
+
+    Args:
+        blueprints_to_load (List[str]): List of blueprint names to load.
+        config (Dict[str, Any]): Configuration dictionary.
+        blueprints_metadata (Dict[str, Dict[str, Any]]): Metadata of available blueprints.
+        args (Any): Parsed command-line arguments.
+    """
+    for blueprint_name in blueprints_to_load:
+        blueprint_class = blueprints_metadata[blueprint_name].get("blueprint_class")
+        if not blueprint_class:
+            logger.warning(f"No blueprint_class defined for blueprint '{blueprint_name}'. Skipping.")
+            continue
+
+        blueprint_instance = blueprint_class(config=config)
+        logger.info(f"Running blueprint '{blueprint_name}' in '{args.mode}' mode.")
+
+        if args.mode == "cli":
+            try:
+                blueprint_instance.interactive_mode(stream=False)
+                logger.info(f"Blueprint '{blueprint_name}' executed in CLI mode.")
+            except Exception as e:
+                logger.error(f"Error running blueprint '{blueprint_name}' in CLI mode: {e}")
+        elif args.mode == "rest":
+            try:
+                # Implement REST mode logic here
+                # Example: blueprint_instance.rest_mode()
+                logger.info(f"Blueprint '{blueprint_name}' executed in REST mode.")
+            except Exception as e:
+                logger.error(f"Error running blueprint '{blueprint_name}' in REST mode: {e}")
+        elif args.mode == "mcp-host":
+            try:
+                # Implement MCP-host mode logic here
+                # Example: blueprint_instance.mcp_host_mode()
+                logger.info(f"Blueprint '{blueprint_name}' executed in MCP-host mode.")
+            except Exception as e:
+                logger.error(f"Error running blueprint '{blueprint_name}' in MCP-host mode: {e}")
+        else:
+            logger.error(f"Unsupported mode: {args.mode}")
+            print(color_text(f"Unsupported mode: {args.mode}", "red"))
+
+
+def prompt_user_to_select_blueprint(blueprints_metadata: Dict[str, Dict[str, Any]]) -> Optional[str]:
+    """
+    Allow the user to select a blueprint from available options.
+
+    Args:
+        blueprints_metadata (Dict[str, Dict[str, Any]]): Metadata of available blueprints.
+
+    Returns:
+        Optional[str]: Selected blueprint name, or None if no selection is made.
+    """
+    if not blueprints_metadata:
+        logger.warning("No blueprints available. Blueprint selection skipped.")
+        print(color_text("No blueprints available. Please add blueprints to continue.", "yellow"))
+        return None
+
+    print("\nAvailable Blueprints:")
+    for idx, (key, metadata) in enumerate(blueprints_metadata.items(), start=1):
+        print(f"{idx}. {metadata.get('title', key)} - {metadata.get('description', 'No description available')}")
+
+    while True:
+        try:
+            choice_input = input("\nEnter the number of the blueprint you want to run (0 to cancel): ").strip()
+            if not choice_input:
+                print(f"Please enter a number between 0 and {len(blueprints_metadata)}.")
+                logger.warning("User entered empty input for blueprint selection.")
+                continue
+
+            choice = int(choice_input)
+            if choice == 0:
+                logger.info("User chose to cancel blueprint selection.")
+                return None
+            elif 1 <= choice <= len(blueprints_metadata):
+                selected_key = list(blueprints_metadata.keys())[choice - 1]
+                logger.info(f"User selected blueprint: '{selected_key}'")
+                return selected_key
+            else:
+                print(f"Please enter a number between 0 and {len(blueprints_metadata)}.")
+                logger.warning(f"User entered invalid blueprint number: {choice}")
+        except ValueError:
+            print("Invalid input. Please enter a valid number.")
+            logger.warning("User entered non-integer value for blueprint selection.")
+
+
+def main():
+    """
+    Main entry point for the blueprint runner CLI.
+    """
+    parser = argparse.ArgumentParser(description="Blueprint Runner CLI")
+    parser.add_argument(
+        "blueprint_path",
+        type=str,
+        help="Path to the blueprint's Python file."
+    )
+    parser.add_argument(
+        "--interactive",
+        action="store_true",
+        help="Run the blueprint in interactive mode."
+    )
+    parser.add_argument(
+        "--mode",
+        type=str,
+        choices=["cli", "rest", "mcp-host"],
+        default="cli",
+        help="Mode to run the blueprint."
+    )
+
+    args = parser.parse_args()
+
+    try:
+        blueprint_module = load_blueprint(args.blueprint_path)
+    except ImportError as e:
+        print(color_text(str(e), "red"))
+        sys.exit(1)
+
+    if args.interactive:
+        try:
+            run_blueprint_interactive(blueprint_module)
+        except AttributeError as e:
+            print(color_text(str(e), "red"))
+            sys.exit(1)
+    else:
+        try:
+            run_blueprint_framework(blueprint_module)
+        except AttributeError as e:
+            print(color_text(str(e), "red"))
+            sys.exit(1)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        print("\nReceived shutdown signal (Ctrl+C)")
+        logger.info("Received shutdown signal (Ctrl+C)")
+        sys.exit(0)
+    except Exception as e:
+        logger.error(f"Unhandled exception: {e}")
+        print(color_text(f"\nFatal error: {e}", "red"))
+        sys.exit(1)
+    finally:
+        logger.info("Blueprint runner terminated.")
+        sys.exit(0)

swarm/extensions/cli/cli_args.py

@@ -0,0 +1,88 @@
+# src/swarm/extensions/blueprint/modes/cli_mode/cli_args.py
+
+import argparse
+from typing import Namespace
+
+def parse_arguments() -> Namespace:
+    """
+    Parse command-line arguments for dynamic LLM configuration, MCP server management, and other overrides.
+
+    Returns:
+        argparse.Namespace: Parsed command-line arguments.
+    """
+    parser = argparse.ArgumentParser(
+        description="Run Open Swarm MCP in various modes or manage configurations."
+    )
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # Subparser for running modes
+    run_parser = subparsers.add_parser("run", help="Run Open Swarm MCP in various modes.")
+    run_parser.add_argument(
+        "--mode",
+        type=str,
+        choices=["cli", "rest", "mcp-host"],
+        default="cli",
+        help="Select the mode to run the MCP (cli, rest, mcp-host). Default is 'cli'."
+    )
+    run_parser.add_argument(
+        "--config",
+        type=str,
+        default=None,  # Will be set dynamically in main.py
+        help="Path to the MCP server configuration file."
+    )
+    run_parser.add_argument(
+        "--llm",
+        type=str,
+        help="Override the LLM specified in the config."
+    )
+    run_parser.add_argument(
+        "--llm-model",
+        type=str,
+        help="Override the LLM model specified in the config."
+    )
+    run_parser.add_argument(
+        "--temperature",
+        type=float,
+        help="Override the LLM temperature specified in the config."
+    )
+    run_parser.add_argument(
+        "--blueprint",
+        type=str,
+        action='append',
+        help="Specify one or more blueprints to load (can be used multiple times)."
+    )
+    run_parser.add_argument(
+        "--setup",
+        action='store_true',
+        help="Re-run the setup wizard regardless of existing configuration."
+    )
+
+    # Subparser for configuration management
+    config_parser = subparsers.add_parser("config", help="Manage Swarm MCP configurations.")
+    config_subparsers = config_parser.add_subparsers(dest="config_command", help="Configuration commands")
+
+    # Add LLM
+    add_llm_parser = config_subparsers.add_parser("add-llm", help="Add a new LLM.")
+    # No additional arguments; will use interactive prompts
+
+    # Remove LLM
+    remove_llm_parser = config_subparsers.add_parser("remove-llm", help="Remove an existing LLM.")
+    remove_llm_parser.add_argument(
+        "llm_name",
+        type=str,
+        help="Name of the LLM to remove."
+    )
+
+    # Add MCP server
+    add_server_parser = config_subparsers.add_parser("add-server", help="Add a new MCP server.")
+    # No additional arguments; will use interactive prompts
+
+    # Remove MCP server
+    remove_server_parser = config_subparsers.add_parser("remove-server", help="Remove an existing MCP server.")
+    remove_server_parser.add_argument(
+        "server_name",
+        type=str,
+        help="Name of the MCP server to remove."
+    )
+
+    return parser.parse_args()

swarm/extensions/cli/commands/blueprint_management.py

@@ -0,0 +1,31 @@
+# Handles blueprint discovery and validation for the CLI
+
+from swarm.extensions.blueprint.discovery import discover_blueprints
+from swarm.extensions.config.config_loader import load_server_config
+
+def list_blueprints():
+    """List available blueprints and their metadata."""
+    blueprints = discover_blueprints()
+    if not blueprints:
+        print("No blueprints discovered.")
+        return
+    print("Discovered Blueprints:")
+    for name, metadata in blueprints.items():
+        print(f"- {name}: {metadata.get('description', 'No description available.')}")
+
+cat > src/swarm/extensions/cli/commands/config_management.py << 'EOF'
+# Handles configuration management workflows (e.g., LLM, MCP servers)
+
+from swarm.extensions.config.config_loader import (
+    load_server_config,
+    save_server_config,
+)
+
+def add_llm(model_name, api_key):
+    """Add a new LLM configuration."""
+    config = load_server_config()
+    if "llms" not in config:
+        config["llms"] = {}
+    config["llms"][model_name] = {"api_key": api_key}
+    save_server_config(config)
+    print(f"Added LLM '{model_name}' to configuration.")

swarm/extensions/cli/commands/config_management.py

@@ -0,0 +1,15 @@
+# Handles configuration management workflows (e.g., LLM, MCP servers)
+
+from swarm.extensions.config.config_loader import (
+    load_server_config,
+    save_server_config,
+)
+
+def add_llm(model_name, api_key):
+    """Add a new LLM configuration."""
+    config = load_server_config()
+    if "llms" not in config:
+        config["llms"] = {}
+    config["llms"][model_name] = {"api_key": api_key}
+    save_server_config(config)
+    print(f"Added LLM '{model_name}' to configuration.")

swarm/extensions/cli/commands/edit_config.py

@@ -0,0 +1,77 @@
+import argparse
+import json
+from swarm.extensions.config.config_loader import (
+    load_server_config,
+    save_server_config,
+)
+from pathlib import Path
+
+CONFIG_PATH = Path("swarm_config.json").resolve()
+
+def list_config(config):
+    """
+    List current configuration settings.
+    
+    Args:
+        config (dict): The current configuration.
+    """
+    print(json.dumps(config, indent=4))
+
+def edit_config_interactive(config):
+    """
+    Interactive editing of the configuration file.
+    
+    Args:
+        config (dict): The current configuration.
+    """
+    print("Current configuration:")
+    list_config(config)
+
+    print("\nEdit the settings (leave blank to keep current value):")
+    for key, value in config.items():
+        new_value = input(f"{key} [{value}]: ").strip()
+        if new_value:
+            config[key] = new_value
+
+    print("\nUpdated configuration:")
+    list_config(config)
+
+def edit_config_field(config, field, value):
+    """
+    Edit a specific field in the configuration.
+    
+    Args:
+        config (dict): The current configuration.
+        field (str): The field to edit.
+        value (str): The new value for the field.
+    """
+    if field not in config:
+        print(f"Field '{field}' not found in configuration.")
+        return
+    config[field] = value
+    print(f"Updated {field} to {value}.")
+
+def main():
+    parser = argparse.ArgumentParser(description="Edit the swarm_config.json file.")
+    parser.add_argument("--list", action="store_true", help="List current configuration")
+    parser.add_argument("--field", help="The configuration field to edit")
+    parser.add_argument("--value", help="The new value for the specified field")
+    parser.add_argument("--interactive", action="store_true", help="Interactively edit the configuration")
+    args = parser.parse_args()
+
+    try:
+        config = load_server_config(str(CONFIG_PATH))
+    except FileNotFoundError as e:
+        print(f"Error: {e}")
+        return
+
+    if args.list:
+        list_config(config)
+    elif args.interactive:
+        edit_config_interactive(config)
+        save_server_config(str(CONFIG_PATH), config)
+    elif args.field and args.value:
+        edit_config_field(config, args.field, args.value)
+        save_server_config(str(CONFIG_PATH), config)
+    else:
+        parser.print_help()

swarm/extensions/cli/commands/list_blueprints.py

@@ -0,0 +1,22 @@
+"""
+Command: list_blueprints
+Description: Lists all blueprints available in the system.
+"""
+
+from pathlib import Path
+from swarm.extensions.blueprint.blueprint_discovery import discover_blueprints
+
+# Metadata for dynamic registration
+description = "Lists all blueprints available in the system."
+usage = "list_blueprints"
+
+def list_blueprints():
+    """Returns a list of blueprints."""
+    blueprints_dir = Path(__file__).resolve().parent.parent.parent / "blueprints"
+    return discover_blueprints([str(blueprints_dir)])
+
+def execute():
+    """Execute the command to list blueprints."""
+    blueprints = list_blueprints()
+    for blueprint_id, metadata in blueprints.items():
+        print(f"Blueprint ID: {blueprint_id}, Title: {metadata.get('title', 'No title')}")

swarm/extensions/cli/commands/validate_env.py

@@ -0,0 +1,57 @@
+import os
+import argparse
+from swarm.extensions.config.config_loader import load_server_config
+from swarm.extensions.blueprint.blueprint_base import BlueprintBase
+
+CONFIG_PATH = "swarm_config.json"
+
+def validate_all_env_vars(config):
+    """
+    Validate all environment variables for the current configuration.
+    """
+    required_vars = config.get("required_env_vars", [])
+    missing_vars = [var for var in required_vars if var not in os.environ]
+
+    if missing_vars:
+        print(f"Missing environment variables: {', '.join(missing_vars)}")
+        return False
+    print("All required environment variables are set.")
+    return True
+
+def validate_blueprint_env_vars(config, blueprint_name):
+    """
+    Validate environment variables for a specific blueprint.
+
+    Args:
+        config (dict): The configuration dictionary.
+        blueprint_name (str): The name of the blueprint to validate.
+    """
+    blueprint_config = config.get("blueprints", {}).get(blueprint_name, {})
+    blueprint = BlueprintBase(blueprint_config)
+    required_vars = blueprint.required_env_vars()
+    missing_vars = [var for var in required_vars if var not in os.environ]
+
+    if missing_vars:
+        print(f"Missing environment variables for blueprint '{blueprint_name}': {', '.join(missing_vars)}")
+        return False
+    print(f"All required environment variables are set for blueprint '{blueprint_name}'.")
+    return True
+
+def main():
+    parser = argparse.ArgumentParser(description="Validate environment variables.")
+    parser.add_argument("--blueprint", help="Validate environment variables for a specific blueprint.")
+    args = parser.parse_args()
+
+    try:
+        config = load_server_config(CONFIG_PATH)
+    except FileNotFoundError as e:
+        print(f"Error: {e}")
+        return
+
+    if args.blueprint:
+        validate_blueprint_env_vars(config, args.blueprint)
+    else:
+        validate_all_env_vars(config)
+
+if __name__ == "__main__":
+    main()

swarm/extensions/cli/commands/validate_envvars.py

@@ -0,0 +1,39 @@
+from swarm.extensions.blueprint.blueprint_discovery import discover_blueprints
+from swarm.extensions.config.config_loader import load_env_config, validate_env_vars
+import argparse
+
+def validate_envvars(blueprint_name=None):
+    """
+    Validate environment variables for blueprints.
+
+    Args:
+        blueprint_name (str, optional): The name of the blueprint to validate.
+                                         Validates all blueprints if None.
+    """
+    # Discover blueprints
+    blueprints = discover_blueprints(["blueprints"])
+
+    if blueprint_name:
+        blueprint = blueprints.get(blueprint_name)
+        if not blueprint:
+            print(f"Blueprint '{blueprint_name}' not found.")
+            return
+        required_vars = blueprint.get("env_vars", [])
+        env_vars = load_env_config()
+        validation = validate_env_vars(env_vars, required_vars)
+        print(f"Validation for '{blueprint_name}': {validation}")
+    else:
+        # Global validation
+        env_vars = load_env_config()
+        print("Global Environment Validation:")
+        for blueprint_name, blueprint_data in blueprints.items():
+            required_vars = blueprint_data.get("env_vars", [])
+            validation = validate_env_vars(env_vars, required_vars)
+            print(f"Validation for '{blueprint_name}': {validation}")
+
+def main():
+    parser = argparse.ArgumentParser(description="Validate environment variables.")
+    parser.add_argument("--blueprint", help="Specify a blueprint to validate")
+    args = parser.parse_args()
+
+    validate_envvars(blueprint_name=args.blueprint)

swarm/extensions/cli/interactive_shell.py

@@ -0,0 +1,41 @@
+"""
+Interactive CLI shell for dynamic commands.
+"""
+
+from swarm.extensions.cli.utils.discover_commands import discover_commands
+import os
+
+COMMANDS_DIR = os.path.join(os.path.dirname(__file__), "commands")
+
+def interactive_shell():
+    """Launch an interactive CLI shell."""
+    commands = discover_commands(COMMANDS_DIR)
+
+    print("Welcome to the Swarm CLI Interactive Shell!")
+    print("Type 'help' to see available commands, or 'exit' to quit.")
+
+    while True:
+        try:
+            user_input = input("swarm> ").strip()
+            if user_input == "exit":
+                print("Exiting CLI shell.")
+                break
+            elif user_input == "help":
+                show_help(commands)
+            elif user_input in commands:
+                command = commands[user_input]["execute"]
+                if command:
+                    command()
+                else:
+                    print(f"Command '{user_input}' is not executable.")
+            else:
+                print(f"Unknown command: {user_input}")
+        except KeyboardInterrupt:
+            print("\nExiting CLI shell.")
+            break
+
+def show_help(commands):
+    """Display available commands."""
+    print("Available commands:")
+    for cmd, metadata in commands.items():
+        print(f" - {cmd}: {metadata['description']}")

swarm/extensions/cli/main.py

@@ -0,0 +1,36 @@
+"""
+Main entry point for Swarm CLI.
+"""
+
+import argparse
+import os
+from swarm.extensions.cli.utils.discover_commands import discover_commands
+from swarm.extensions.cli.interactive_shell import interactive_shell
+
+COMMANDS_DIR = os.path.join(os.path.dirname(__file__), "commands")
+
+def parse_args(commands):
+    """Parse CLI arguments dynamically."""
+    parser = argparse.ArgumentParser(description="Swarm CLI Utility")
+    subparsers = parser.add_subparsers(dest="command")
+
+    for cmd_name, metadata in commands.items():
+        subparsers.add_parser(cmd_name, help=metadata["description"])
+
+    return parser.parse_args()
+
+def main():
+    commands = discover_commands(COMMANDS_DIR)
+    args = parse_args(commands)
+
+    if args.command:
+        command = commands.get(args.command, {}).get("execute")
+        if command:
+            command()
+        else:
+            print(f"Command '{args.command}' is not executable.")
+    else:
+        interactive_shell()
+
+if __name__ == "__main__":
+    main()