open-swarm 0.1.1744937124__py3-none-any.whl → 0.1.1744942852__py3-none-any.whl

swarm/extensions/config/setup_wizard.py

@@ -1,103 +0,0 @@
-# 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/extensions/config/utils/logger.py

@@ -1,36 +0,0 @@
-# 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

swarm/extensions/launchers/build_launchers.py

@@ -1,14 +0,0 @@
-#!/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/build_swarm_wrapper.py

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

swarm/extensions/launchers/swarm_api.py

@@ -1,68 +0,0 @@
-#!/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/extensions/launchers/swarm_cli.py

@@ -1,216 +0,0 @@
-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/extensions/launchers/swarm_wrapper.py

@@ -1,29 +0,0 @@
-#!/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()