open-swarm 0.1.1745275181__py3-none-any.whl → 0.1.1748636295__py3-none-any.whl

swarm/{core → extensions/config}/config_manager.py

@@ -6,11 +6,17 @@ import sys
 import logging
 from typing import Any, Dict
 
-from swarm.core.server_config import load_server_config, save_server_config
+from swarm.extensions.config.config_loader import (
+    load_server_config,
+    resolve_placeholders
+)
 from swarm.utils.color_utils import color_text
 from swarm.settings import DEBUG
-from swarm.core.utils.logger import *
-from swarm.extensions.cli.utils.prompt_user import prompt_user
+from swarm.extensions.cli.utils import (
+    prompt_user,
+    log_and_exit,
+    display_message
+)
 
 # Initialize logger for this module
 logger = logging.getLogger(__name__)
@@ -23,24 +29,6 @@ if not logger.handlers:
 
 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.
@@ -52,10 +40,10 @@ def backup_configuration(config_path: str) -> None:
     try:
         shutil.copy(config_path, backup_path)
         logger.info(f"Configuration backup created at '{backup_path}'")
-        print(f"Backup of configuration 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}")
-        print(f"Failed to create backup: {e}")
+        display_message(f"Failed to create backup: {e}", "error")
         sys.exit(1)
 
 def load_config(config_path: str) -> Dict[str, Any]:
@@ -78,11 +66,11 @@ def load_config(config_path: str) -> Dict[str, Any]:
             logger.debug(f"Raw configuration loaded: {config}")
     except FileNotFoundError:
         logger.error(f"Configuration file not found at {config_path}")
-        print(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}")
-        print(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
@@ -91,7 +79,7 @@ def load_config(config_path: str) -> Dict[str, Any]:
         logger.debug(f"Configuration after resolving placeholders: {resolved_config}")
     except Exception as e:
         logger.error(f"Failed to resolve placeholders in configuration: {e}")
-        print(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
@@ -111,10 +99,10 @@ def save_config(config_path: str, config: Dict[str, Any]) -> None:
         with open(config_path, "w") as f:
             json.dump(config, f, indent=4)
         logger.info(f"Configuration saved to '{config_path}'")
-        print(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}")
-        print(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:
@@ -125,20 +113,20 @@ def add_llm(config_path: str) -> None:
         config_path (str): Path to the configuration file.
     """
     config = load_config(config_path)
-    print("Starting the process to add a new LLM.")
+    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()
-        print(f"User entered LLM name: {llm_name}")
+        display_message(f"User entered LLM name: {llm_name}", "info")
         if llm_name.lower() == 'done':
-            print("Finished adding LLMs.")
+            display_message("Finished adding LLMs.", "info")
             break
         if not llm_name:
-            print("LLM name cannot be empty.")
+            display_message("LLM name cannot be empty.", "error")
             continue
 
         if llm_name in config.get("llm", {}):
-            print(f"LLM '{llm_name}' already exists.")
+            display_message(f"LLM '{llm_name}' already exists.", "warning")
             continue
 
         llm = {}
@@ -154,16 +142,16 @@ def add_llm(config_path: str) -> None:
             temperature_input = prompt_user("Enter the temperature (e.g., 0.7)").strip()
             llm["temperature"] = float(temperature_input)
         except ValueError:
-            print("Invalid temperature value. Using default 0.7.")
+            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.")
-        print(f"LLM '{llm_name}' added.")
+        display_message(f"LLM '{llm_name}' added.", "info")
 
     backup_configuration(config_path)
     save_config(config_path, config)
-    print("LLM configuration process completed.")
+    display_message("LLM configuration process completed.", "info")
 
 def remove_llm(config_path: str, llm_name: str) -> None:
     """
@@ -176,18 +164,18 @@ def remove_llm(config_path: str, llm_name: str) -> None:
     config = load_config(config_path)
 
     if llm_name not in config.get("llm", {}):
-        print(f"LLM '{llm_name}' does not exist.")
+        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']:
-        print("Operation cancelled.")
+        display_message("Operation cancelled.", "warning")
         return
 
     del config["llm"][llm_name]
     backup_configuration(config_path)
     save_config(config_path, config)
-    print(f"LLM '{llm_name}' has been removed.")
+    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:
@@ -198,20 +186,20 @@ def add_mcp_server(config_path: str) -> None:
         config_path (str): Path to the configuration file.
     """
     config = load_config(config_path)
-    print("Starting the process to add a new MCP server.")
+    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()
-        print(f"User entered MCP server name: {server_name}")
+        display_message(f"User entered MCP server name: {server_name}", "info")
         if server_name.lower() == 'done':
-            print("Finished adding MCP servers.")
+            display_message("Finished adding MCP servers.", "info")
             break
         if not server_name:
-            print("Server name cannot be empty.")
+            display_message("Server name cannot be empty.", "error")
             continue
 
         if server_name in config.get("mcpServers", {}):
-            print(f"MCP server '{server_name}' already exists.")
+            display_message(f"MCP server '{server_name}' already exists.", "warning")
             continue
 
         server = {}
@@ -222,7 +210,7 @@ def add_mcp_server(config_path: str) -> None:
             if not isinstance(server["args"], list):
                 raise ValueError
         except ValueError:
-            print("Invalid arguments format. Using an empty list.")
+            display_message("Invalid arguments format. Using an empty list.", "warning")
             server["args"] = []
 
         env_vars = {}
@@ -238,11 +226,11 @@ def add_mcp_server(config_path: str) -> None:
 
         config.setdefault("mcpServers", {})[server_name] = server
         logger.info(f"Added MCP server '{server_name}' to configuration.")
-        print(f"MCP server '{server_name}' added.")
+        display_message(f"MCP server '{server_name}' added.", "info")
 
     backup_configuration(config_path)
     save_config(config_path, config)
-    print("MCP server configuration process completed.")
+    display_message("MCP server configuration process completed.", "info")
 
 def remove_mcp_server(config_path: str, server_name: str) -> None:
     """
@@ -255,16 +243,16 @@ def remove_mcp_server(config_path: str, server_name: str) -> None:
     config = load_config(config_path)
 
     if server_name not in config.get("mcpServers", {}):
-        print(f"MCP server '{server_name}' does not exist.")
+        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']:
-        print("Operation cancelled.")
+        display_message("Operation cancelled.", "warning")
         return
 
     del config["mcpServers"][server_name]
     backup_configuration(config_path)
     save_config(config_path, config)
-    print(f"MCP server '{server_name}' has been removed.")
+    display_message(f"MCP server '{server_name}' has been removed.", "info")
     logger.info(f"Removed MCP server '{server_name}' from configuration.")

swarm/{core → extensions/config}/server_config.py

@@ -47,35 +47,3 @@ def save_server_config(config: dict, file_path: str = None) -> None:
     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/extensions/launchers/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/extensions/launchers/swarm_api.py

@@ -1,12 +1,68 @@
-"""
-Swarm API entry point for installation via PyPI or local dev.
-"""
+#!/usr/bin/env python3
+import argparse
+import subprocess
 import sys
-import os
-from swarm.core.swarm_api import main
+from os import path, listdir, makedirs
 
-def main_entry():
-    main()
+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_entry()
+    main()

swarm/extensions/launchers/swarm_cli.py

@@ -1,12 +1,304 @@
-"""
-Swarm CLI entry point for installation via PyPI or local dev.
-"""
-import sys
+#!/usr/bin/env python3
+import argparse
+import importlib.util
 import os
-from swarm.extensions.cli.main import main
+import sys
+import subprocess
+import shutil
+import json
+import PyInstaller.__main__
 
-def app():
-    main()
+def resolve_env_vars(data):
+    if isinstance(data, dict):
+        return {k: resolve_env_vars(v) for k, v in data.items()}
+    elif isinstance(data, list):
+        return [resolve_env_vars(item) for item in data]
+    elif isinstance(data, str):
+        return os.path.expandvars(data)
+    else:
+        return data
+
+MANAGED_DIR = os.path.expanduser("~/.swarm/blueprints")
+BIN_DIR = os.path.expanduser("~/.swarm/bin")
+
+def ensure_managed_dir():
+    if not os.path.exists(MANAGED_DIR):
+        os.makedirs(MANAGED_DIR, exist_ok=True)
+    if not os.path.exists(BIN_DIR):
+        os.makedirs(BIN_DIR, exist_ok=True)
+
+def add_blueprint(source_path, blueprint_name=None):
+    source_path = os.path.normpath(source_path)
+    if not os.path.exists(source_path):
+        print("Error: source file/directory does not exist:", source_path)
+        sys.exit(1)
+    if os.path.isdir(source_path):
+        if not blueprint_name:
+            blueprint_name = os.path.basename(os.path.normpath(source_path))
+        target_dir = os.path.join(MANAGED_DIR, blueprint_name)
+        if os.path.exists(target_dir):
+            shutil.rmtree(target_dir)
+        os.makedirs(target_dir, exist_ok=True)
+        for root, dirs, files in os.walk(source_path):
+            rel_path = os.path.relpath(root, source_path)
+            dest_root = os.path.join(target_dir, rel_path) if rel_path != '.' else target_dir
+            os.makedirs(dest_root, exist_ok=True)
+            for file in files:
+                shutil.copy2(os.path.join(root, file), os.path.join(dest_root, file))
+        print(f"Blueprint '{blueprint_name}' added successfully to {target_dir}.")
+    else:
+        blueprint_file = source_path
+        if not blueprint_name:
+            base = os.path.basename(blueprint_file)
+            if base.startswith("blueprint_") and base.endswith(".py"):
+                blueprint_name = base[len("blueprint_"):-3]
+            else:
+                blueprint_name = os.path.splitext(base)[0]
+        target_dir = os.path.join(MANAGED_DIR, blueprint_name)
+        os.makedirs(target_dir, exist_ok=True)
+        target_file = os.path.join(target_dir, f"blueprint_{blueprint_name}.py")
+        shutil.copy2(blueprint_file, target_file)
+        print(f"Blueprint '{blueprint_name}' added successfully to {target_dir}.")
+
+def list_blueprints():
+    ensure_managed_dir()
+    entries = os.listdir(MANAGED_DIR)
+    blueprints = [d for d in entries if os.path.isdir(os.path.join(MANAGED_DIR, d))]
+    if blueprints:
+        print("Registered blueprints:")
+        for bp in blueprints:
+            print(" -", bp)
+    else:
+        print("No blueprints registered.")
+
+def delete_blueprint(blueprint_name):
+    target_dir = os.path.join(MANAGED_DIR, blueprint_name)
+    if os.path.exists(target_dir) and os.path.isdir(target_dir):
+        shutil.rmtree(target_dir)
+        print(f"Blueprint '{blueprint_name}' deleted successfully.")
+    else:
+        print(f"Error: Blueprint '{blueprint_name}' does not exist.")
+        sys.exit(1)
+
+def run_blueprint(blueprint_name):
+    target_dir = os.path.join(MANAGED_DIR, blueprint_name)
+    blueprint_file = os.path.join(target_dir, f"blueprint_{blueprint_name}.py")
+    if not os.path.exists(blueprint_file):
+        print(f"Error: Blueprint file not found for '{blueprint_name}'. Install it using 'swarm-cli add <path>'.")
+        sys.exit(1)
+    spec = importlib.util.spec_from_file_location("blueprint_module", blueprint_file)
+    if spec is None or spec.loader is None:
+        print("Error: Failed to load blueprint module from:", blueprint_file)
+        sys.exit(1)
+    blueprint = importlib.util.module_from_spec(spec)
+    loader = spec.loader
+    src_path = os.path.join(os.getcwd(), "src")
+    if src_path not in sys.path:
+        sys.path.insert(0, src_path)
+    loader.exec_module(blueprint)
+    if hasattr(blueprint, "main"):
+        blueprint.main()
+    else:
+        print("Error: The blueprint does not have a main() function.")
+        sys.exit(1)
+
+def install_blueprint(blueprint_name):
+    target_dir = os.path.join(MANAGED_DIR, blueprint_name)
+    blueprint_file = os.path.join(target_dir, f"blueprint_{blueprint_name}.py")
+    if not os.path.exists(blueprint_file):
+        print(f"Error: Blueprint '{blueprint_name}' is not registered. Add it using 'swarm-cli add <path>'.")
+        sys.exit(1)
+    cli_name = blueprint_name  # Use blueprint_name as default cli_name for simplicity
+    try:
+        PyInstaller.__main__.run([
+            blueprint_file,
+            "--onefile",
+            "--name", cli_name,
+            "--distpath", BIN_DIR,
+            "--workpath", os.path.join(target_dir, "build"),
+            "--specpath", target_dir
+        ])
+    except KeyboardInterrupt:
+        print("Installation aborted by user request.")
+        sys.exit(1)
+    print(f"Blueprint '{blueprint_name}' installed as CLI utility '{cli_name}' at: {os.path.join(BIN_DIR, cli_name)}")
+
+def uninstall_blueprint(blueprint_name, blueprint_only=False, wrapper_only=False):
+    target_dir = os.path.join(MANAGED_DIR, blueprint_name)
+    blueprint_file = os.path.join(target_dir, f"blueprint_{blueprint_name}.py")
+    cli_name = blueprint_name  # Default to blueprint_name for uninstall
+    cli_path = os.path.join(BIN_DIR, cli_name)
+    removed = False
+    
+    if not blueprint_only and not wrapper_only:  # Remove both by default
+        if os.path.exists(target_dir):
+            shutil.rmtree(target_dir)
+            print(f"Blueprint '{blueprint_name}' removed from {MANAGED_DIR}.")
+            removed = True
+        if os.path.exists(cli_path):
+            os.remove(cli_path)
+            print(f"Wrapper '{cli_name}' removed from {BIN_DIR}.")
+            removed = True
+    elif blueprint_only:
+        if os.path.exists(target_dir):
+            shutil.rmtree(target_dir)
+            print(f"Blueprint '{blueprint_name}' removed from {MANAGED_DIR}.")
+            removed = True
+    elif wrapper_only:
+        if os.path.exists(cli_path):
+            os.remove(cli_path)
+            print(f"Wrapper '{cli_name}' removed from {BIN_DIR}.")
+            removed = True
+    
+    if not removed:
+        print(f"Error: Nothing to uninstall for '{blueprint_name}' with specified options.")
+        sys.exit(1)
+
+def main():
+    os.environ.pop("SWARM_BLUEPRINTS", None)
+    parser = argparse.ArgumentParser(
+        description="Swarm CLI Launcher\n\nSubcommands:\n"
+                    "  add     : Add a blueprint to the managed directory.\n"
+                    "  list    : List registered blueprints.\n"
+                    "  delete  : Delete a registered blueprint.\n"
+                    "  run     : Run a blueprint by name.\n"
+                    "  install : Install a blueprint as a CLI utility with PyInstaller.\n"
+                    "  uninstall : Uninstall a blueprint and/or its CLI wrapper.\n"
+                    "  migrate : Apply Django database migrations.\n"
+                    "  config  : Manage swarm configuration (LLM and MCP servers).",
+        formatter_class=argparse.RawTextHelpFormatter)
+    subparsers = parser.add_subparsers(dest="command", required=True, help="Available subcommands")
+    
+    parser_add = subparsers.add_parser("add", help="Add a blueprint from a file or directory.")
+    parser_add.add_argument("source", help="Source blueprint file or directory.")
+    parser_add.add_argument("--name", help="Optional blueprint name. If not provided, inferred from filename.")
+    
+    parser_list = subparsers.add_parser("list", help="List registered blueprints.")
+    
+    parser_delete = subparsers.add_parser("delete", help="Delete a registered blueprint by name.")
+    parser_delete.add_argument("name", help="Blueprint name to delete.")
+    
+    parser_run = subparsers.add_parser("run", help="Run a blueprint by name.")
+    parser_run.add_argument("name", help="Blueprint name to run.")
+    parser_run.add_argument("--config", default="~/.swarm/swarm_config.json", help="Path to configuration file.")
+    
+    parser_install = subparsers.add_parser("install", help="Install a blueprint as a CLI utility with PyInstaller.")
+    parser_install.add_argument("name", help="Blueprint name to install as a CLI utility.")
+    
+    parser_uninstall = subparsers.add_parser("uninstall", help="Uninstall a blueprint and/or its CLI wrapper.")
+    parser_uninstall.add_argument("name", help="Blueprint name to uninstall.")
+    parser_uninstall.add_argument("--blueprint-only", action="store_true", help="Remove only the blueprint directory.")
+    parser_uninstall.add_argument("--wrapper-only", action="store_true", help="Remove only the CLI wrapper.")
+    
+    parser_migrate = subparsers.add_parser("migrate", help="Apply Django database migrations.")
+    
+    parser_config = subparsers.add_parser("config", help="Manage swarm configuration (LLM and MCP servers).")
+    parser_config.add_argument("action", choices=["add", "list", "remove"], help="Action to perform on configuration")
+    parser_config.add_argument("--section", required=True, choices=["llm", "mcpServers"], help="Configuration section to manage")
+    parser_config.add_argument("--name", help="Name of the configuration entry (required for add and remove)")
+    parser_config.add_argument("--json", help="JSON string for configuration entry (required for add)")
+    parser_config.add_argument("--config", default="~/.swarm/swarm_config.json", help="Path to configuration file")
+    
+    args = parser.parse_args()
+    ensure_managed_dir()
+    
+    if args.command == "add":
+        add_blueprint(args.source, args.name)
+    elif args.command == "list":
+        list_blueprints()
+    elif args.command == "delete":
+        delete_blueprint(args.name)
+    elif args.command == "run":
+        config_path = os.path.expanduser(args.config)
+        if not os.path.exists(config_path):
+            os.makedirs(os.path.dirname(config_path), exist_ok=True)
+            default_config = {"llm": {}, "mcpServers": {}}
+            with open(config_path, 'w') as f:
+                json.dump(default_config, f, indent=4)
+            print("Default config file created at:", config_path)
+        run_blueprint(args.name)
+    elif args.command == "install":
+        install_blueprint(args.name)
+    elif args.command == "uninstall":
+        uninstall_blueprint(args.name, args.blueprint_only, args.wrapper_only)
+    elif args.command == "migrate":
+        try:
+            subprocess.run(["python", "manage.py", "migrate"], check=True)
+            print("Migrations applied successfully.")
+        except subprocess.CalledProcessError as e:
+            print("Error applying migrations:", e)
+            sys.exit(1)
+    elif args.command == "config":
+        config_path = os.path.expanduser(args.config)
+        if not os.path.exists(config_path):
+            default_conf = {"llm": {}, "mcpServers": {}}
+            os.makedirs(os.path.dirname(config_path), exist_ok=True)
+            with open(config_path, "w") as f:
+                json.dump(default_conf, f, indent=4)
+            print("Default config file created at:", config_path)
+            config = default_conf
+        else:
+            try:
+                with open(config_path, "r") as f:
+                    config = json.load(f)
+            except json.JSONDecodeError:
+                print("Error: Invalid configuration file.")
+                sys.exit(1)
+        section = args.section
+        if args.action == "list":
+            entries = config.get(section, {})
+            if entries:
+                print(f"Entries in {section}:")
+                for key, value in entries.items():
+                    print(f" - {key}: {json.dumps(value, indent=4)}")
+            else:
+                print(f"No entries found in {section}.")
+        elif args.action == "add":
+            if args.section == "mcpServers" and not args.name:
+                if not args.json:
+                    print("Error: --json is required for adding an mcpServers block when --name is omitted.")
+                    sys.exit(1)
+                try:
+                    update_data = json.loads(args.json)
+                except json.JSONDecodeError:
+                    print("Error: --json must be a valid JSON string.")
+                    sys.exit(1)
+                if "mcpServers" not in update_data:
+                    print("Error: JSON block must contain 'mcpServers' key for merging.")
+                    sys.exit(1)
+                config.setdefault("mcpServers", {})
+                config["mcpServers"].update(update_data["mcpServers"])
+                with open(config_path, "w") as f:
+                    json.dump(config, f, indent=4)
+                print("MCP servers updated in configuration.")
+            else:
+                if not args.name or not args.json:
+                    print("Error: --name and --json are required for adding an entry.")
+                    sys.exit(1)
+                try:
+                    entry_data = json.loads(args.json)
+                except json.JSONDecodeError:
+                    print("Error: --json must be a valid JSON string.")
+                    sys.exit(1)
+                config.setdefault(section, {})[args.name] = entry_data
+                with open(config_path, "w") as f:
+                    json.dump(config, f, indent=4)
+                print(f"Entry '{args.name}' added to {section} in configuration.")
+        elif args.action == "remove":
+            if not args.name:
+                print("Error: --name is required for removing an entry.")
+                sys.exit(1)
+            if args.name in config.get(section, {}):
+                del config[section][args.name]
+                with open(config_path, "w") as f:
+                    json.dump(config, f, indent=4)
+                print(f"Entry '{args.name}' removed from {section} in configuration.")
+            else:
+                print(f"Error: Entry '{args.name}' not found in {section}.")
+                sys.exit(1)
+    else:
+        parser.print_help()
+        sys.exit(1)
 
 if __name__ == "__main__":
-    app()
+    main()