solace-agent-mesh 0.2.3__py3-none-any.whl → 1.0.1__py3-none-any.whl

solace_agent_mesh/cli/commands/plugin/build.py

@@ -1,268 +0,0 @@
-import subprocess
-import os
-import click
-
-from cli.utils import (
-    log_error,
-    apply_document_parsers,
-    load_plugin,
-    get_formatted_names,
-)
-from cli.config import Config
-
-
-def build_command():
-    """Builds the plugin python module."""
-    subprocess.check_call(["python", "-m", "build"])
-
-
-def get_all_plugin_gateway_interfaces(config, abort, return_plugin_config=False):
-    plugins = config.get("plugins", [])
-    gateway_interfaces = {}
-
-    for plugin in plugins:
-        if plugin.get("includes_gateway_interface"):
-            name = plugin.get("name")
-            plugin_path = load_plugin(name, return_path_only=True)
-            if not plugin_path:
-                log_error(f"Plugin '{name}' is not installed.")
-                abort()
-            interface_path = os.path.join(plugin_path, "interfaces")
-
-            if not os.path.exists(interface_path):
-                continue
-
-            interface_gateway_configs = (
-                (
-                    Config.load_config(
-                        os.path.join(plugin_path, Config.user_plugin_config_file)
-                    )
-                    or {}
-                )
-                .get("solace_agent_mesh_plugin", {})
-                .get("interface_gateway_configs", {})
-            )
-            interface_gateway_config = None
-            # Ensuring flow and default pair exist
-            interface_pairs = {}
-            for file in os.listdir(interface_path):
-                if file.endswith("-flows.yaml"):
-                    name = file.split("-flows.yaml")[0]
-                    if name not in interface_pairs:
-                        interface_pairs[name] = []
-                    interface_pairs[name].append(file)
-
-                elif file.endswith("-default-config.yaml"):
-                    name = file.split("-default-config.yaml")[0]
-                    if name not in interface_pairs:
-                        interface_pairs[name] = []
-                    interface_pairs[name].append(file)
-
-            for name, files in interface_pairs.items():
-                if len(files) == 2:
-                    if return_plugin_config:
-                        for (
-                            interface_name,
-                            interface_config,
-                        ) in interface_gateway_configs.items():
-                            if interface_name == name.replace("-", "_"):
-                                interface_gateway_config = interface_config
-                                break
-                        gateway_interfaces[name] = (
-                            interface_path,
-                            interface_gateway_config,
-                        )
-                    else:
-                        gateway_interfaces[name] = interface_path
-
-    return gateway_interfaces
-
-
-def build_plugins(
-    config,
-    build_config_dir,
-    abort,
-    parsers,
-    plugin_gateway_interfaces,
-    build_specific_gateway,
-):
-    plugins = config.get("plugins", [])
-    plugins_overwrite_dir = os.path.join(build_config_dir, "..", "overwrites")
-
-    os.makedirs(build_config_dir, exist_ok=True)
-    os.makedirs(plugins_overwrite_dir, exist_ok=True)
-
-    for plugin in plugins:
-        click.echo("Building plugin: " + plugin.get("name"))
-        name = plugin.get("name")
-        load_unspecified_files = plugin.get("load_unspecified_files", True)
-        load = plugin.get("load", {})
-        agents_to_load = [
-            agent.replace("-", "_") for agent in (load.get("agents") or [])
-        ]
-        gateways_to_load = load.get("gateways") or []
-        overwrites_to_load = load.get("overwrites") or []
-
-        plugin_path = load_plugin(name, return_path_only=True)
-        if not plugin_path:
-            log_error(f"Plugin '{name}' is not installed.")
-            abort()
-
-        try:
-            # Path to plugin config in the module
-            plugin_file_path = os.path.join(plugin_path, Config.user_plugin_config_file)
-            plugin_config = Config.load_config(plugin_file_path)
-
-            if not plugin_config or "solace_agent_mesh_plugin" not in plugin_config:
-                raise ValueError("Invalid solace-agent-mesh plugin module.")
-        except Exception:
-            log_error(
-                f"Error loading plugin '{name}': Invalid solace-agent-mesh plugin module."
-            )
-            abort()
-
-        ################
-        # Build Agents #
-        ################
-        agent_config_path = os.path.join(plugin_path, "configs", "agents")
-        if os.path.exists(agent_config_path):
-            click.echo("Building agents for plugin: " + name)
-            # Get all agent configuration files
-            agent_configs = [
-                f for f in os.listdir(agent_config_path) if f.endswith(".yaml")
-            ]
-            yaml_agents = [f"{agent}.yaml" for agent in agents_to_load]
-            if not load_unspecified_files:
-                agent_configs = [f for f in agent_configs if f in yaml_agents]
-
-            # Ensuring all user requested agents are present
-            for agent_config in yaml_agents:
-                if agent_config not in agent_configs:
-                    log_error(
-                        f"Agent '{agent_config[:-5]}' was not found in the plugin '{name}'"
-                    )
-                    abort()
-
-            for agent_config in agent_configs:
-                try:
-                    # Read agent configuration file
-                    agent_config_file = os.path.join(agent_config_path, agent_config)
-                    with open(agent_config_file, "r", encoding="utf-8") as f:
-                        agent_config_content = f.read()
-                    # Apply document parsers
-                    meta = {
-                        "skip_relative_import_path": True,
-                        "extra_literals": {
-                            "MODULE_DIRECTORY": f"{name}.src",
-                        },
-                    }
-                    agent_config_content = apply_document_parsers(
-                        agent_config_content, parsers, meta
-                    )
-                    # Perform name substitutions
-                    base_agent_name = agent_config[:-5]  # Remove .yaml
-                    name_cases = get_formatted_names(base_agent_name)
-                    for case, val in name_cases.items():
-                        agent_config_content = agent_config_content.replace(
-                            f"{{{{{case}}}}}", val
-                        )
-
-                    # Write agent configuration to build directory
-                    agent_build_path = os.path.join(
-                        build_config_dir, "agent_" + agent_config
-                    )
-                    with open(agent_build_path, "w", encoding="utf-8") as f:
-                        f.write(agent_config_content)
-                except IOError as e:
-                    log_error(
-                        f'Error reading agent configuration file for "{agent_config}" from plugin "{name}": {e}'
-                    )
-                    abort()
-                except Exception as e:
-                    log_error(
-                        f'Error building agent configuration for "{agent_config}" from plugin "{name}": {e}'
-                    )
-                    abort()
-
-        ##################
-        # Build Gateways #
-        ##################
-        gateway_config_path = os.path.join(plugin_path, "configs", "gateways")
-        gateway_dirs = [gateway.replace("-", "_") for gateway in gateways_to_load]
-        if os.path.exists(gateway_config_path):
-            gateway_subdirs = os.listdir(gateway_config_path)
-            for gateway in gateway_dirs:
-                if gateway not in gateway_subdirs:
-                    log_error(
-                        f"Gateway '{gateway}' was not found in the plugin '{name}'"
-                    )
-                    abort()
-
-            # Loop over the subdirectories of gateways_config_path
-            for gateway in gateway_subdirs:
-                if load_unspecified_files or gateway in gateway_dirs:
-                    build_specific_gateway(
-                        build_config_dir,
-                        abort,
-                        parsers,
-                        gateway_config_path,
-                        gateway,
-                        plugin_gateway_interfaces,
-                    )
-
-        ####################
-        # Build Overwrites #
-        ####################
-        overwrite_config_path = os.path.join(plugin_path, "configs", "overwrite")
-        if os.path.exists(overwrite_config_path):
-            click.echo("Building overwrite for plugin: " + name)
-            # Get all overwrite configuration files
-            overwrite_configs = [
-                f for f in os.listdir(overwrite_config_path) if f.endswith(".yaml")
-            ]
-            if not load_unspecified_files:
-                overwrite_configs = [
-                    f for f in overwrite_configs if f in overwrites_to_load
-                ]
-
-            # Ensuring all user requested overwrites are present
-            for overwrite_config in overwrites_to_load:
-                if overwrite_config not in overwrite_configs:
-                    log_error(
-                        f"Overwrite '{overwrite_config}' was not found in the plugin '{name}'"
-                    )
-                    abort()
-            for overwrite_config in overwrite_configs:
-                try:
-                    # Read overwrite configuration file
-                    overwrite_config_file = os.path.join(
-                        overwrite_config_path, overwrite_config
-                    )
-                    with open(overwrite_config_file, "r", encoding="utf-8") as f:
-                        overwrite_config_content = f.read()
-                    # Apply document parsers
-                    meta = {
-                        "skip_relative_import_path": True,
-                        "extra_literals": {
-                            "MODULE_DIRECTORY": f"{name}.src",
-                        },
-                    }
-                    overwrite_config_content = apply_document_parsers(
-                        overwrite_config_content, parsers, meta
-                    )
-                    # Write overwrite configuration to build directory
-                    overwrite_build_path = os.path.join(
-                        plugins_overwrite_dir, overwrite_config
-                    )
-                    with open(overwrite_build_path, "w", encoding="utf-8") as f:
-                        f.write(overwrite_config_content)
-                except IOError as e:
-                    log_error(
-                        f'Error reading overwrite configuration file for "{overwrite_config}" from plugin "{name}": {e}'
-                    )
-                    abort()
-                except Exception as e:
-                    log_error(
-                        f'Error building overwrite configuration for "{overwrite_config}" from plugin "{name}": {e}'
-                    )
-                    abort()

solace_agent_mesh/cli/commands/plugin/create.py

@@ -1,117 +0,0 @@
-import click
-import os
-
-from cli.config import Config
-from cli.utils import load_template
-from cli.utils import log_error, ask_question
-
-
-DEFAULT_DESCRIPTION = "A solace-agent-mesh plugin project."
-DEFAULT_AUTHOR = "Author Name"
-EMPTY_FILE_MSG = ""
-
-def create_command(
-    path: str, description: str = None, author: str = None, skip: bool = False
-):
-    """Initializes and creates a new solace-agent-mesh plugin project.
-
-    Project structure:
-
-    plugin-name/
-    ├─ configs/
-    │  ├─ overwrite/
-    ├─ src/
-    │  ├─ __init__.py
-    │  ├─ agents/
-    │  │  ├─ __init__.py
-    │  ├─ gateways/
-    │  │  ├─ __init__.py
-    ├─ interfaces/
-    ├─ solace-agent-mesh-plugin.yaml
-    ├─ .gitignore
-    ├─ pyproject.toml
-    ├─ README.md
-
-    """
-    if not skip:
-        if not path:
-            path = ask_question("Plugin name (A path if it shouldn't be created in the current directory)")
-        if not description:
-            description = ask_question("Plugin description", "")
-        if not author:
-            author = ask_question("Plugin author", "")
-    if not path:
-        log_error("Plugin name is required.")
-        return 1
-    click.echo(f"Creating solace-agent-mesh plugin '{path}'.")
-
-    # Create the plugin directory
-    click.echo("Creating plugin directory...")
-    os.makedirs(path, exist_ok=True)
-
-    # Check into the plugin directory
-    os.chdir(path)
-
-    # Get the directory base name
-    name = str(os.path.basename(path))
-
-    config = Config.get_default_plugin_config()
-    config["solace_agent_mesh_plugin"]["name"] = name
-
-    # Write the plugin config file
-    Config.write_config(config, Config.user_plugin_config_file)
-
-    # Create the .gitignore file
-    ignore_files = ["*.pyc", "__pycache__", "*.egg-info", "dist"]
-    with open(".gitignore", "w", encoding="utf-8") as f:
-        f.write("\n".join(ignore_files))
-
-    # Create README.md
-    with open("README.md", "w", encoding="utf-8") as f:
-        f.write(f"# {name.upper()}\n\n{description or DEFAULT_DESCRIPTION}")
-
-    # Create directories and __init__.py files
-    py_paths = ["agents", "gateways"]
-    py_paths = [os.path.join("src", path) for path in py_paths]
-    directories = [
-        "interfaces",
-        "configs",
-        "src",
-        os.path.join("configs", "overwrite"),
-    ] + py_paths
-
-    for path in directories:
-        os.makedirs(path, exist_ok=True)
-
-    for py_path in py_paths:
-        with open(os.path.join(py_path, "__init__.py"), "w", encoding="utf-8") as f:
-            f.write("")
-
-    with open(os.path.join("configs", ".gitkeep"), "w", encoding="utf-8") as f:
-        f.write(EMPTY_FILE_MSG)
-
-    with open(os.path.join("interfaces", ".gitkeep"), "w", encoding="utf-8") as f:
-        f.write(EMPTY_FILE_MSG)
-
-    with open(os.path.join("src", "__init__.py"), "w", encoding="utf-8") as f:
-        f.write('__version__ = "0.0.1"\n')
-
-    # Create pyproject.toml
-    pyproject = load_template("plugin-pyproject.toml")
-    pyproject = (pyproject
-        .replace("{{name}}", name)
-        .replace("{{snake_name}}", name.replace("-", "_"))
-        .replace("{{description}}", description or DEFAULT_DESCRIPTION)
-        .replace("{{author}}", author or DEFAULT_AUTHOR)
-    )
-
-    with open("pyproject.toml", "w", encoding="utf-8") as f:
-        f.write(pyproject)
-
-    click.echo(f"Plugin project '{name}' was created successfully.")
-    click.echo(
-        click.style(f"\tUse `cd {name}` to check into project.", fg="blue")
-    )
-    click.echo(
-        click.style("\tUse `solace-agent-mesh add` to add agents and gateways.", fg="blue")
-    )

solace_agent_mesh/cli/commands/plugin/plugin.py

@@ -1,124 +0,0 @@
-import click
-
-from cli.utils import log_error
-from .add import add_command
-from .remove import remove_command
-from .create import create_command
-from .build import build_command
-
-
-def plugin_command(plugin):
-
-    @plugin.command()
-    @click.option(
-        "-n",
-        "--name",
-        help="Plugin name. (A path if it shouldn't be created in the current directory)",
-    )
-    @click.option(
-        "-d",
-        "--description",
-        help="Plugin description.",
-    )
-    @click.option(
-        "-a",
-        "--author",
-        help="Plugin author.",
-    )
-    @click.option(
-        "-s",
-        "--skip",
-        is_flag=True,
-        help="Skip the prompts and use the default values. (Name is required)",
-    )
-    def create(name, description, author, skip):
-        """Initializes and creates a new solace-agent-mesh plugin project."""
-        create_command(name, description, author, skip)
-
-    @plugin.command()
-    def build():
-        """Build the solace-agent-mesh plugin project."""
-        build_command()
-
-    @plugin.command()
-    @click.argument("name")
-    @click.option("--add-all", is_flag=True, help="Added the plugin with default of loading all exported files from the plugin")
-    @click.option("--pip", is_flag=True, help="Install with pip.")
-    @click.option("--uv", is_flag=True, help="Install with uv pip.")
-    @click.option("--poetry", is_flag=True, help="Install with poetry.")
-    @click.option("--conda", is_flag=True, help="Install with conda.")
-    @click.option(
-        "-u",
-        "--from-url",
-        help="Install the plugin from a the given URL instead of the given name. (URL can be a file path or a git URL)",
-    )
-    def add(name, add_all, uv, pip, poetry, conda, from_url):
-        """
-        Add a new plugin to solace-agent-mesh config yaml.
-        Optional install the module if not found.
-
-        Only one installation method can be selected at a time.
-        """
-        # Only one option can be true at a time
-        if sum([uv, pip, poetry, conda]) > 1:
-            log_error("Only one installation method can be selected.")
-            return 1
-        installer = (
-            "uv" if uv 
-            else "pip" if pip 
-            else "poetry" if poetry 
-            else "conda" if conda 
-            else None
-        )
-        return add_command(name, installer, from_url, add_all)
-
-    @plugin.command()
-    @click.argument("name")
-    @click.option(
-        "--pip-uninstall",
-        default=False,
-        is_flag=True,
-        help="Removes the plugin module using pip",
-    )
-    @click.option(
-        "--uv-uninstall",
-        default=False,
-        is_flag=True,
-        help="Removes the plugin module using uv.",
-    )
-    @click.option(
-        "--poetry-uninstall",
-        default=False,
-        is_flag=True,
-        help="Removes the plugin module using poetry",
-    )
-    @click.option(
-        "--conda-uninstall",
-        default=False,
-        is_flag=True,
-        help="Removes the plugin module using conda",
-    )
-    def remove(name, pip_uninstall, uv_uninstall, poetry_uninstall, conda_uninstall):
-        """
-        Remove a plugin by removing it from solace-agent-mesh config yaml
-        Optionally uninstall the module.
-
-        Only one uninstallation method can be selected at a time.
-        """
-        # Only one option can be true at a time
-        if sum([pip_uninstall, uv_uninstall, poetry_uninstall, conda_uninstall]) > 1:
-            log_error("Only one uninstallation method can be selected.")
-            return 1
-
-        installer = (
-            "pip"
-            if pip_uninstall
-            else "uv"
-            if uv_uninstall
-            else "poetry"
-            if poetry_uninstall
-            else "conda"
-            if conda_uninstall
-            else None
-        )
-        return remove_command(name, installer)

solace_agent_mesh/cli/commands/plugin/remove.py

@@ -1,73 +0,0 @@
-import subprocess
-import importlib.util
-import click
-
-from cli.utils import log_error
-from cli.config import Config
-
-
-def remove_command(name: str, installer: str = None):
-    """
-    Remove a plugin by removing it from solace-agent-mesh config yaml
-    Optionally uninstall the module
-
-    Args:
-        name (str): The name of the module to remove.
-        installer (str, optional): Installer to use for uninstallation.
-                                   Should be one of 'pip', 'poetry', 'conda', or None.
-    """
-    name = name.replace("-", "_")
-    sam_config = Config.get_user_config()
-    if not sam_config:
-        log_error("No configuration found.")
-        return 1
-
-    plugin = None
-    plugins = sam_config.get("solace_agent_mesh", {}).get("plugins", [])
-    for p in plugins:
-        if p.get("name") == name:
-            plugin = p
-            plugins.remove(plugin)
-            Config.write_config(sam_config)
-            click.echo(f"Plugin '{name}' was removed from solace-agent-mesh config.")
-            break
-
-    if not plugin:
-        log_error(f"Plugin '{name}' not found in the config.")
-        return
-
-    if installer:
-        # Check if the module exists
-        if importlib.util.find_spec(name) is None:
-            log_error(
-                f"Module '{name}' is not installed. Run without uninstall flag to just remove from config."
-            )
-            return 1
-
-        # Attempt to uninstall using the specified installer
-        click.echo(f"Attempting to uninstall module '{name}' using {installer}...")
-        try:
-            if installer == "pip":
-                subprocess.check_call(["pip3", "uninstall", "-y", name])
-            elif installer == "uv":
-                subprocess.check_call(["uv", "pip", "uninstall", "-y", name])
-            elif installer == "poetry":
-                subprocess.check_call(["poetry", "remove", name])
-            elif installer == "conda":
-                subprocess.check_call(["conda", "remove", "-y", name])
-            else:
-                log_error(
-                    f"Unsupported installer: {installer} - (pip, poetry, or conda)."
-                )
-                return 1
-            click.echo(f"Successfully uninstalled module '{name}'.")
-        except subprocess.CalledProcessError as e:
-            log_error(f"Error occurred while uninstalling module '{name}': {e}")
-            return 1
-    else:
-        click.echo(
-            click.style(
-                f"Module '{name}' was only removed from the config. Use your package manager to uninstall from environment.",
-                fg="yellow",
-            )
-        )

solace_agent_mesh/cli/commands/run.py

@@ -1,68 +0,0 @@
-import sys
-import os
-import click
-
-from cli.commands.build import build_command
-from cli.utils import log_error
-
-
-def run_solace_ai_connector(configs):
-    try:
-        from solace_ai_connector.main import main
-    except ImportError:
-        log_error("Failed to import Solace AI Connector.")
-        return 1
-
-    sys.argv = [sys.argv[0].replace("solace-agent-mesh", "solace-ai-connector"), *configs]
-    return sys.exit(main())
-
-
-FILES_TO_EXCLUDE = []
-
-
-def run_command(
-    use_system_env, config_files, exclude_files, quick_build, ignore_build, force_build
-):
-    """Run the Solace Agent Mesh application."""
-
-    config = click.get_current_context().obj["solace_agent_mesh"]
-    build_dir = config["build"]["build_directory"]
-    build_config_dir = os.path.join(build_dir, "configs")
-
-    if force_build or (not ignore_build and not os.path.exists(build_dir)):
-        build_command(skip_without_asking=quick_build)
-
-    click.echo("Running Solace Agent Mesh application")
-
-    if not use_system_env:
-        try:
-            from dotenv import load_dotenv
-
-            env_file = config["env_file"]
-            load_dotenv(env_file, override=True)
-        except ImportError:
-            log_error(
-                "Failed to import dotenv. Please install it using 'pip install python-dotenv'"
-            )
-            return 1
-        except Exception as e:
-            log_error(f"Failed to load environment variables. {e}")
-            return 1
-
-    if not config_files:
-        if not os.path.exists(build_config_dir):
-            log_error("No build directory found. Run 'solace-agent-mesh build' first.")
-            return 1
-
-        config_files = [
-            os.path.join(build_config_dir, f)
-            for f in os.listdir(build_config_dir)
-            if f.endswith(".yaml")
-        ]
-
-    # Exclude files
-    # only basename of the files
-    exclude_files = [os.path.basename(f) for f in exclude_files] + FILES_TO_EXCLUDE
-    config_files = [f for f in config_files if os.path.basename(f) not in exclude_files]
-
-    return run_solace_ai_connector(config_files)