solace-agent-mesh 0.0.1__py3-none-any.whl → 0.1.1__py3-none-any.whl

solace_agent_mesh/cli/commands/plugin/build.py

@@ -0,0 +1,217 @@
+import subprocess
+import os
+import click
+
+from cli.utils import log_error, apply_document_parsers, load_plugin
+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): 
+    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
+
+            # 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:
+                    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
+                    )
+                    # 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

@@ -0,0 +1,117 @@
+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 = "THIS WILL IS ONLY HERE TO PREVENT GIT FROM IGNORING THIS DIRECTORY"
+
+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", "__TEMPLATES_WILL_BE_HERE__"), "w", encoding="utf-8") as f:
+        f.write(EMPTY_FILE_MSG)
+
+    with open(os.path.join("interfaces", "__INTERFACES_WILL_BE_HERE__"), "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

@@ -0,0 +1,109 @@
+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("--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, 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([pip, poetry, conda]) > 1:
+            log_error("Only one installation method can be selected.")
+            return 1
+        installer = "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(
+        "--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, 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, poetry_uninstall, conda_uninstall]) > 1:
+            log_error("Only one uninstallation method can be selected.")
+            return 1
+
+        installer = (
+            "pip"
+            if pip_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

@@ -0,0 +1,71 @@
+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(["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

@@ -0,0 +1,68 @@
+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_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 use_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)