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

swarm/core/server_config.py

@@ -0,0 +1,81 @@
+"""
+Module for managing server configuration files, including saving and validation.
+
+Provides utilities to save configurations to disk and ensure integrity of data.
+"""
+
+import json
+import os
+import logging
+from swarm.utils.redact import redact_sensitive_data
+
+# Initialize logger for this module
+logger = logging.getLogger(__name__)
+DEBUG = os.getenv("DEBUG", "False").lower() in ("true", "1", "t")  # Define DEBUG locally
+logger.setLevel(logging.DEBUG if DEBUG else logging.INFO)
+stream_handler = logging.StreamHandler()
+formatter = logging.Formatter("[%(levelname)s] %(asctime)s - %(name)s - %(message)s")
+stream_handler.setFormatter(formatter)
+if not logger.handlers:
+    logger.addHandler(stream_handler)
+
+def save_server_config(config: dict, file_path: str = None) -> None:
+    """
+    Saves the server configuration to a JSON file.
+
+    Args:
+        config (dict): The configuration dictionary to save.
+        file_path (str): The path to save the configuration file. Defaults to 'swarm_settings.json' in the current directory.
+
+    Raises:
+        ValueError: If the configuration is not a valid dictionary.
+        OSError: If there are issues writing to the file.
+    """
+    if not isinstance(config, dict):
+        logger.error("Provided configuration is not a dictionary.")
+        raise ValueError("Configuration must be a dictionary.")
+
+    if file_path is None:
+        file_path = os.path.join(os.getcwd(), "swarm_settings.json")
+
+    logger.debug(f"Saving server configuration to {file_path}")
+    try:
+        with open(file_path, "w") as file:
+            json.dump(config, file, indent=4)
+            logger.info(f"Configuration successfully saved to {file_path}")
+            logger.debug(f"Saved configuration: {redact_sensitive_data(config)}")
+    except OSError as e:
+        logger.error(f"Error saving configuration to {file_path}: {e}")
+        raise
+
+def load_server_config(file_path: str = None) -> dict:
+    """
+    Loads the server configuration from a JSON file.
+
+    Args:
+        file_path (str): The path to the configuration file. Defaults to 'swarm_settings.json' in the current directory.
+
+    Returns:
+        dict: The loaded configuration dictionary.
+
+    Raises:
+        FileNotFoundError: If the configuration file does not exist.
+        ValueError: If the configuration is not a valid dictionary or JSON is invalid.
+    """
+    if file_path is None:
+        file_path = os.path.join(os.getcwd(), "swarm_settings.json")
+    logger.debug(f"Loading server configuration from {file_path}")
+    try:
+        with open(file_path, "r") as file:
+            config = json.load(file)
+            if not isinstance(config, dict):
+                logger.error("Loaded configuration is not a dictionary.")
+                raise ValueError("Configuration must be a dictionary.")
+            logger.debug(f"Loaded configuration: {redact_sensitive_data(config)}")
+            return config
+    except FileNotFoundError as e:
+        logger.error(f"Configuration file not found: {file_path}")
+        raise
+    except json.JSONDecodeError as e:
+        logger.error(f"Invalid JSON in configuration file {file_path}: {e}")
+        raise ValueError(f"Invalid JSON in configuration file: {e}")

swarm/core/setup_wizard.py

@@ -0,0 +1,103 @@
+# src/swarm/extensions/config/setup_wizard.py
+
+import os
+import json
+from typing import Dict, Any
+
+def run_setup_wizard(config_path: str, blueprints_metadata: Dict[str, Dict[str, Any]]) -> Dict[str, Any]:
+    """
+    Runs the interactive setup wizard.
+
+    Args:
+        config_path (str): Path to the configuration file.
+        blueprints_metadata (Dict[str, Dict[str, Any]]): Metadata for available blueprints.
+
+    Returns:
+        Dict[str, Any]: Updated configuration.
+    """
+    config = {
+        "llm_providers": {},
+        "mcpServers": {}
+    }
+
+    # Configure LLM settings
+    print("Configuring LLM providers:")
+    while True:
+        provider_name = input("Enter the name of the LLM provider to add (e.g., 'openai', 'ollama'), or type 'done' to finish: ").strip()
+        if provider_name.lower() in ['done', 'exit', 'quit']:
+            break
+        if not provider_name:
+            print("Provider name cannot be empty.")
+            continue
+        if provider_name in config["llm_providers"]:
+            print(f"LLM provider '{provider_name}' already exists.")
+            continue
+
+        provider = {}
+        provider["provider"] = input("Enter the provider identifier (e.g., 'openai', 'ollama'): ").strip()
+        provider["model"] = input("Enter the model name (e.g., 'gpt-4'): ").strip()
+        provider["base_url"] = input("Enter the base URL for the API (e.g., 'https://api.openai.com/v1'): ").strip()
+        provider["api_key"] = input("Enter the environment variable for the API key (e.g., 'OPENAI_API_KEY') [Leave empty if not required]: ").strip()
+        temperature_input = input("Enter the temperature for the model (e.g., 0.7): ").strip()
+        try:
+            provider["temperature"] = float(temperature_input)
+        except ValueError:
+            print("Invalid temperature value. Using default 0.7.")
+            provider["temperature"] = 0.7
+
+        config["llm_providers"][provider_name] = provider
+        print(f"LLM provider '{provider_name}' added successfully.\n")
+
+    # Select a default LLM provider
+    if config["llm_providers"]:
+        print("\nAvailable LLM Providers:")
+        for idx, provider in enumerate(config["llm_providers"].keys(), start=1):
+            print(f"{idx}. {provider}")
+        while True:
+            try:
+                default_choice = input("Enter the number of the LLM provider to set as default: ").strip()
+                default_choice = int(default_choice)
+                if 1 <= default_choice <= len(config["llm_providers"]):
+                    default_provider = list(config["llm_providers"].keys())[default_choice - 1]
+                    config["llm_providers"]["default"] = config["llm_providers"][default_provider]
+                    print(f"Default LLM provider set to '{default_provider}'.\n")
+                    break
+                else:
+                    print(f"Please enter a number between 1 and {len(config['llm_providers'])}.")
+            except ValueError:
+                print("Invalid input. Please enter a valid number.")
+    else:
+        print("No LLM providers configured.")
+
+    # Select a blueprint
+    print("\nAvailable Blueprints:")
+    for idx, (key, metadata) in enumerate(blueprints_metadata.items(), start=1):
+        print(f"{idx}. {key}: {metadata.get('title', 'No title')} - {metadata.get('description', 'No description')}")
+
+    while True:
+        try:
+            blueprint_choice = input("\nEnter the number of the blueprint to use (0 to skip): ").strip()
+            if blueprint_choice.lower() in ["q", "quit", "exit"]:  # Handle exit inputs
+                print("Exiting blueprint selection.")
+                break
+
+            blueprint_choice = int(blueprint_choice)
+            if blueprint_choice == 0:
+                print("No blueprint selected.")
+                break
+            elif 1 <= blueprint_choice <= len(blueprints_metadata):
+                selected_blueprint_key = list(blueprints_metadata.keys())[blueprint_choice - 1]
+                config["blueprint"] = selected_blueprint_key
+                print(f"Selected Blueprint: {selected_blueprint_key}\n")
+                break
+            else:
+                print(f"Invalid selection. Please enter a number between 0 and {len(blueprints_metadata)}.")
+        except ValueError:
+            print("Invalid input. Please enter a valid number.")
+
+    # Save configuration
+    with open(config_path, "w") as config_file:
+        json.dump(config, config_file, indent=4)
+    print(f"Configuration saved to {config_path}.\n")
+
+    return config

swarm/core/slash_commands.py

@@ -0,0 +1,17 @@
+# Minimal slash_commands.py to restore compatibility
+
+class SlashCommandRegistry:
+    def __init__(self):
+        self.commands = {}
+    def register(self, command, func=None):
+        if func is None:
+            def decorator(f):
+                self.commands[command] = f
+                return f
+            return decorator
+        self.commands[command] = func
+        return func
+    def get(self, command):
+        return self.commands.get(command)
+
+slash_registry = SlashCommandRegistry()

swarm/core/spinner.py

@@ -0,0 +1,100 @@
+"""
+Simple terminal spinner for interactive feedback during long operations.
+"""
+
+import os
+import sys
+import threading
+import time
+from typing import Optional
+
+class Spinner:
+    """Simple terminal spinner for interactive feedback."""
+    # Define spinner characters (can be customized)
+    SPINNER_CHARS = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+    # Custom status sequences for special cases
+    STATUS_SEQUENCES = {
+        'generating': ['Generating.', 'Generating..', 'Generating...'],
+        'running': ['Running...']
+    }
+
+    def __init__(self, interactive: bool, custom_sequence: str = None):
+        """
+        Initialize the spinner.
+
+        Args:
+            interactive (bool): Hint whether the environment is interactive.
+                                Spinner is disabled if False or if output is not a TTY.
+            custom_sequence (str): Optional name for a custom status sequence (e.g., 'generating', 'running').
+        """
+        self.interactive = interactive
+        self.is_tty = sys.stdout.isatty()
+        self.enabled = self.interactive and self.is_tty
+        self.running = False
+        self.thread: Optional[threading.Thread] = None
+        self.status = ""
+        self.index = 0
+        self.custom_sequence = custom_sequence
+        self.sequence_idx = 0
+
+    def start(self, status: str = "Processing..."):
+        """Start the spinner with an optional status message."""
+        if not self.enabled or self.running:
+            return # Do nothing if disabled or already running
+        self.status = status
+        self.running = True
+        self.sequence_idx = 0
+        self.thread = threading.Thread(target=self._spin, daemon=True)
+        self.thread.start()
+
+    def stop(self):
+        """Stop the spinner and clear the line."""
+        if not self.enabled or not self.running:
+            return # Do nothing if disabled or not running
+        self.running = False
+        if self.thread is not None:
+            self.thread.join() # Wait for the thread to finish
+        sys.stdout.write("\r\033[K")
+        sys.stdout.flush()
+        self.thread = None
+
+    def _spin(self):
+        """Internal method running in the spinner thread to animate."""
+        start_time = time.time()
+        warned = False
+        while self.running:
+            elapsed = time.time() - start_time
+            if self.custom_sequence and self.custom_sequence in self.STATUS_SEQUENCES:
+                seq = self.STATUS_SEQUENCES[self.custom_sequence]
+                # If taking longer than 10s, show special message
+                if elapsed > 10 and not warned:
+                    msg = f"{seq[-1]} Taking longer than expected"
+                    warned = True
+                else:
+                    msg = seq[self.sequence_idx % len(seq)]
+                sys.stdout.write(f"\r{msg}\033[K")
+                sys.stdout.flush()
+                self.sequence_idx += 1
+            else:
+                char = self.SPINNER_CHARS[self.index % len(self.SPINNER_CHARS)]
+                sys.stdout.write(f"\r{char} {self.status}\033[K")
+                sys.stdout.flush()
+                self.index += 1
+            time.sleep(0.4 if self.custom_sequence else 0.1)
+
+# Example usage (if run directly)
+if __name__ == "__main__":
+    print("Starting spinner test...")
+    s = Spinner(interactive=True) # Assume interactive for testing
+    s.start("Doing something cool")
+    try:
+        time.sleep(5) # Simulate work
+        s.stop()
+        print("Spinner stopped.")
+        s.start("Doing another thing")
+        time.sleep(3)
+    except KeyboardInterrupt:
+        print("\nInterrupted.")
+    finally:
+        s.stop() # Ensure spinner stops on exit/error
+        print("Test finished.")

swarm/core/swarm_api.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+import argparse
+import subprocess
+import sys
+from os import path, listdir, makedirs
+
+def main():
+    parser = argparse.ArgumentParser(description="Swarm REST Launcher")
+    parser.add_argument("--blueprint", required=True, help="Comma-separated blueprint file paths or names for configuration purposes")
+    parser.add_argument("--port", type=int, default=8000, help="Port to run the REST server")
+    parser.add_argument("--config", default="~/.swarm/swarm_config.json", help="Configuration file path")
+    parser.add_argument("--daemon", action="store_true", help="Run in daemon mode and print process id")
+    args = parser.parse_args()
+
+    # Split blueprints by comma and strip whitespace
+    bp_list = [bp.strip() for bp in args.blueprint.split(",") if bp.strip()]
+    blueprint_paths = []
+    for bp_arg in bp_list:
+        resolved = None
+        if path.exists(bp_arg):
+            if path.isdir(bp_arg):
+                resolved = bp_arg
+                print(f"Using blueprint directory: {resolved}")
+            else:
+                resolved = bp_arg
+                print(f"Using blueprint file: {resolved}")
+        else:
+            managed_path = path.expanduser("~/.swarm/blueprints/" + bp_arg)
+            if path.isdir(managed_path):
+                matches = [f for f in listdir(managed_path) if f.startswith("blueprint_") and f.endswith(".py")]
+                if not matches:
+                    print("Error: No blueprint file found in managed directory:", managed_path)
+                    sys.exit(1)
+                resolved = path.join(managed_path, matches[0])
+                print(f"Using managed blueprint: {resolved}")
+            else:
+                print("Warning: Blueprint not found:", bp_arg, "- skipping.")
+                continue
+        if resolved:
+            blueprint_paths.append(resolved)
+
+    if not blueprint_paths:
+        print("Error: No valid blueprints found.")
+        sys.exit(1)
+    print("Blueprints to be configured:")
+    for bp in blueprint_paths:
+        print(" -", bp)
+
+    config_path = path.expanduser(args.config)
+    if not path.exists(config_path):
+        makedirs(path.dirname(config_path), exist_ok=True)
+        with open(config_path, 'w') as f:
+            f.write("{}")
+        print("Default config file created at:", config_path)
+
+    print("Launching Django server on port 0.0.0.0:{}".format(args.port))
+    try:
+        if args.daemon:
+            proc = subprocess.Popen(["python", "manage.py", "runserver", f"0.0.0.0:{args.port}"])
+            print("Running in daemon mode. Process ID:", proc.pid)
+        else:
+            subprocess.run(["python", "manage.py", "runserver", f"0.0.0.0:{args.port}"], check=True)
+    except subprocess.CalledProcessError as e:
+        print("Error launching Django server:", e)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

swarm/core/swarm_cli.py

@@ -0,0 +1,216 @@
+import os
+import typer
+import platformdirs
+import subprocess
+import sys
+from pathlib import Path
+import importlib.resources as pkg_resources
+import swarm # Import the main package to access its resources
+
+# --- Configuration ---
+APP_NAME = "swarm"
+APP_AUTHOR = "swarm-authors" # Replace if needed
+
+# Use platformdirs for user-specific data, config locations
+USER_DATA_DIR = Path(os.getenv("SWARM_USER_DATA_DIR", platformdirs.user_data_dir(APP_NAME, APP_AUTHOR)))
+USER_CONFIG_DIR = Path(os.getenv("SWARM_USER_CONFIG_DIR", platformdirs.user_config_dir(APP_NAME, APP_AUTHOR)))
+
+# *** CORRECTED: Define user bin dir as a subdir of user data dir ***
+USER_BIN_DIR = Path(os.getenv("SWARM_USER_BIN_DIR", USER_DATA_DIR / "bin"))
+
+# Derived paths
+BLUEPRINTS_DIR = USER_DATA_DIR / "blueprints"
+INSTALLED_BIN_DIR = USER_BIN_DIR # Keep using this variable name for clarity
+
+# Ensure directories exist
+BLUEPRINTS_DIR.mkdir(parents=True, exist_ok=True)
+INSTALLED_BIN_DIR.mkdir(parents=True, exist_ok=True) # Ensure the user bin dir is created
+USER_CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+
+# --- Typer App ---
+app = typer.Typer(
+    help="Swarm CLI tool for managing blueprints.",
+    add_completion=True # Enable shell completion commands
+)
+
+# --- Helper Functions ---
+def find_entry_point(blueprint_dir: Path) -> str | None:
+    """Placeholder: Finds the main Python script in a blueprint directory."""
+    # Improve this logic: Look for a specific file, check pyproject.toml, etc.
+    for item in blueprint_dir.glob("*.py"):
+        if item.is_file() and not item.name.startswith("_"):
+            return item.name
+    return None
+
+# --- CLI Commands ---
+
+@app.command()
+def install(
+    blueprint_name: str = typer.Argument(..., help="Name of the blueprint directory to install."),
+    # Add options for specifying source dir if needed later
+):
+    """
+    Install a blueprint by creating a standalone executable using PyInstaller.
+    """
+    # Decide where to look for the source blueprint: User dir first, then bundled?
+    # For now, let's assume it must exist in the user dir for installation
+    # TODO: Enhance this to allow installing bundled blueprints directly?
+    source_dir = BLUEPRINTS_DIR / blueprint_name
+    if not source_dir.is_dir():
+        # Could also check bundled blueprints here if desired
+        typer.echo(f"Error: Blueprint source directory not found in user directory: {source_dir}", err=True)
+        typer.echo("Currently, only blueprints placed in the user directory can be installed.", err=True)
+        raise typer.Exit(code=1)
+
+    entry_point = find_entry_point(source_dir)
+    if not entry_point:
+        typer.echo(f"Error: Could not find entry point script in {source_dir}", err=True)
+        raise typer.Exit(code=1)
+
+    entry_point_path = source_dir / entry_point
+    output_bin = INSTALLED_BIN_DIR / blueprint_name
+    dist_path = USER_DATA_DIR / "dist" # PyInstaller dist path within user data
+    build_path = USER_DATA_DIR / "build" # PyInstaller build path within user data
+
+    typer.echo(f"Installing blueprint '{blueprint_name}'...")
+    typer.echo(f"  Source: {source_dir}")
+    typer.echo(f"  Entry Point: {entry_point}")
+    typer.echo(f"  Output Executable: {output_bin}")
+
+    pyinstaller_cmd = [
+        "pyinstaller",
+        "--onefile", # Create a single executable file
+        "--name", str(output_bin.name), # Name of the output executable
+        "--distpath", str(INSTALLED_BIN_DIR), # Output directory for the executable
+        "--workpath", str(build_path), # Directory for temporary build files
+        "--specpath", str(USER_DATA_DIR), # Directory for the .spec file
+        str(entry_point_path), # The main script to bundle
+    ]
+
+    typer.echo(f"Running PyInstaller: {' '.join(map(str, pyinstaller_cmd))}") # Use map(str,...) for Path objects
+
+    try:
+        # Use subprocess.run for better control and error handling
+        result = subprocess.run(pyinstaller_cmd, check=True, capture_output=True, text=True)
+        typer.echo("PyInstaller output:")
+        typer.echo(result.stdout)
+        typer.echo(f"Successfully installed '{blueprint_name}' to {output_bin}")
+    except FileNotFoundError:
+        typer.echo("Error: PyInstaller command not found. Is PyInstaller installed?", err=True)
+        raise typer.Exit(code=1)
+    except subprocess.CalledProcessError as e:
+        typer.echo(f"Error during PyInstaller execution (Return Code: {e.returncode}):", err=True)
+        typer.echo(e.stderr, err=True)
+        typer.echo("Check the output above for details.", err=True)
+        raise typer.Exit(code=1)
+    except Exception as e:
+        typer.echo(f"An unexpected error occurred: {e}", err=True)
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def launch(blueprint_name: str = typer.Argument(..., help="Name of the installed blueprint executable to launch.")):
+    """
+    Launch a previously installed blueprint executable.
+    """
+    executable_path = INSTALLED_BIN_DIR / blueprint_name
+    if not executable_path.is_file() or not os.access(executable_path, os.X_OK):
+        typer.echo(f"Error: Blueprint executable not found or not executable: {executable_path}", err=True)
+        raise typer.Exit(code=1)
+
+    typer.echo(f"Launching '{blueprint_name}' from {executable_path}...")
+    try:
+        # Execute the blueprint directly
+        # Using subprocess.run is generally safer and more flexible than os.execv
+        result = subprocess.run([str(executable_path)], capture_output=True, text=True, check=False) # check=False to handle non-zero exits gracefully
+        typer.echo(f"--- {blueprint_name} Output ---")
+        typer.echo(result.stdout)
+        if result.stderr:
+            typer.echo("--- Errors/Warnings ---", err=True)
+            typer.echo(result.stderr, err=True)
+        typer.echo(f"--- '{blueprint_name}' finished (Return Code: {result.returncode}) ---")
+
+    except Exception as e:
+        typer.echo(f"Error launching blueprint: {e}", err=True)
+        raise typer.Exit(code=1)
+
+
+@app.command(name="list")
+def list_blueprints(
+    installed: bool = typer.Option(False, "--installed", "-i", help="List only installed blueprint executables."),
+    available: bool = typer.Option(False, "--available", "-a", help="List only available blueprints (source dirs).")
+):
+    """
+    Lists available blueprints (bundled and user-provided) and/or installed executables.
+    """
+    list_installed = not available or installed
+    list_available = not installed or available
+
+    # --- List Installed Blueprints ---
+    if list_installed:
+        typer.echo(f"--- Installed Blueprints (in {INSTALLED_BIN_DIR}) ---")
+        found_installed = False
+        if INSTALLED_BIN_DIR.exists():
+            try:
+                for item in INSTALLED_BIN_DIR.iterdir():
+                    # Basic check: is it a file and executable? Refine as needed.
+                    if item.is_file() and os.access(item, os.X_OK):
+                        typer.echo(f"- {item.name}")
+                        found_installed = True
+            except OSError as e:
+                typer.echo(f"(Warning: Could not read installed directory: {e})", err=True)
+        if not found_installed:
+            typer.echo("(No installed blueprint executables found)")
+        typer.echo("") # Add spacing
+
+    # --- List Available Blueprints (Bundled and User) ---
+    if list_available:
+        # --- Bundled ---
+        typer.echo("--- Bundled Blueprints (installed with package) ---")
+        bundled_found = False
+        try:
+            # Use importlib.resources to access the 'blueprints' directory within the installed 'swarm' package
+            bundled_blueprints_path = pkg_resources.files(swarm) / 'blueprints'
+
+            if bundled_blueprints_path.is_dir(): # Check if the directory exists in the package
+                for item in bundled_blueprints_path.iterdir():
+                    # Check if it's a directory containing an entry point (adapt check as needed)
+                    if item.is_dir() and not item.name.startswith("__"): # Skip __pycache__ etc.
+                        entry_point = find_entry_point(item) # Use helper, might need refinement
+                        if entry_point:
+                            typer.echo(f"- {item.name} (entry: {entry_point})")
+                            bundled_found = True
+        except ModuleNotFoundError:
+             typer.echo("(Could not find bundled blueprints - package structure issue?)", err=True)
+        except FileNotFoundError: # Can happen if package data wasn't included correctly
+             typer.echo("(Could not find bundled blueprints path - package data missing?)", err=True)
+        except Exception as e:
+            typer.echo(f"(Error accessing bundled blueprints: {e})", err=True)
+
+        if not bundled_found:
+            typer.echo("(No bundled blueprints found or accessible)")
+        typer.echo("") # Add spacing
+
+        # --- User ---
+        typer.echo(f"--- User Blueprints (in {BLUEPRINTS_DIR}) ---")
+        user_found = False
+        if BLUEPRINTS_DIR.exists() and BLUEPRINTS_DIR.is_dir():
+            try:
+                for item in BLUEPRINTS_DIR.iterdir():
+                    if item.is_dir():
+                        entry_point = find_entry_point(item) # Use helper
+                        if entry_point:
+                            typer.echo(f"- {item.name} (entry: {entry_point})")
+                            user_found = True
+            except OSError as e:
+                typer.echo(f"(Warning: Could not read user blueprints directory: {e})", err=True)
+
+        if not user_found:
+            typer.echo("(No user blueprints found)")
+        typer.echo("") # Add spacing
+
+
+# --- Main Execution Guard ---
+if __name__ == "__main__":
+    app()

swarm/core/swarm_wrapper.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+import os
+import sys
+import subprocess
+
+MANAGED_DIR = os.path.expanduser("~/.swarm/blueprints")
+BIN_DIR = os.path.expanduser("~/.swarm/bin")
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: swarm-wrapper <cli_name> [args...]")
+        sys.exit(1)
+    
+    cli_name = sys.argv[1]
+    blueprint_name = cli_name  # Default assumption; could map via config if needed
+    blueprint_dir = os.path.join(MANAGED_DIR, blueprint_name)
+    blueprint_file = os.path.join(blueprint_dir, f"blueprint_{blueprint_name}.py")
+    cli_path = os.path.join(BIN_DIR, cli_name)
+    
+    if os.path.exists(cli_path):
+        # Run the installed CLI
+        subprocess.run([cli_path] + sys.argv[2:], check=False)
+    else:
+        print(f"Error: Blueprint '{blueprint_name}' not installed for CLI '{cli_name}'.")
+        print(f"Please install it using: swarm-cli add <path_to_{blueprint_name}> && swarm-cli install {blueprint_name}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

swarm/core/utils/logger.py

@@ -0,0 +1,36 @@
+# src/swarm/config/utils/logger.py
+
+import logging
+from typing import Optional
+
+def setup_logger(name: str, level: int = logging.DEBUG, log_file: Optional[str] = None) -> logging.Logger:
+    """
+    Sets up and returns a logger with the specified name and level.
+
+    Args:
+        name (str): The name of the logger.
+        level (int, optional): Logging level. Defaults to logging.DEBUG.
+        log_file (str, optional): File path to log to. If None, logs to console. Defaults to None.
+
+    Returns:
+        logging.Logger: Configured logger instance.
+    """
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+    
+    # Prevent adding multiple handlers to the logger
+    if not logger.handlers:
+        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+        
+        if log_file:
+            file_handler = logging.FileHandler(log_file)
+            file_handler.setLevel(level)
+            file_handler.setFormatter(formatter)
+            logger.addHandler(file_handler)
+        
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(level)
+        console_handler.setFormatter(formatter)
+        logger.addHandler(console_handler)
+    
+    return logger