open-swarm 0.1.1743070217__py3-none-any.whl → 0.1.1743364176__py3-none-any.whl

swarm/extensions/launchers/swarm_cli.py

@@ -1,304 +1,216 @@
-#!/usr/bin/env python3
-import argparse
-import importlib.util
 import os
-import sys
+import typer
+import platformdirs
 import subprocess
-import shutil
-import json
-import PyInstaller.__main__
+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
 
-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
+# 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)
 
-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)
+# --- Typer App ---
+app = typer.Typer(
+    help="Swarm CLI tool for managing blueprints.",
+    add_completion=True # Enable shell completion commands
+)
 
-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}.")
+# --- 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
 
-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.")
+# --- CLI Commands ---
 
-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)
+@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)
 
-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)
+    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
 
-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)}")
+        # 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)
+
 
-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)
+@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)
 
-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":
+    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:
-            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:
+            # 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:
-                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)
+                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__":
-    main()
+    app()