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

solace_agent_mesh/cli/commands/add/add.py

@@ -0,0 +1,88 @@
+import click
+
+from .agent import add_agent_command
+from .gateway import add_gateway_command, add_interface_command
+from .copy_from_plugin import copy_from_plugin
+from ...config import Config
+from ...utils import log_error
+
+
+def add_command(add):
+    @add.command()
+    @click.argument("name")
+    @click.option(
+        "-c",
+        "--copy-from",
+        help="Name of the plugin. Copying over an agent config from an existing plugin instead of creating a new one to allow for customization. If your desired agent name is different from the source agent name, use the format <plugin>:<source_agent_name>",
+    )
+    def agent(name, copy_from):
+        """
+        Creates a template for an agent.
+
+        name: Name of the component to create. Must be kebab-case. (don't add 'agent' to the name)
+        """
+        if copy_from:
+            return copy_from_plugin(name, copy_from, "agents")
+        return add_agent_command(name)
+
+    @add.command()
+    @click.argument("name")
+    @click.option(
+        "-i",
+        "--interface",
+        help="The interface(s) to add to the gateway. For example, to add rest and slack interfaces use: --interface slack --interface rest-api",
+        multiple=True,
+    )
+    @click.option(
+        "-c",
+        "--copy-from",
+        help="Name of the plugin. Copying over a gateway configs from an existing plugin instead of creating a new one to allow for customization. If your desired gateway name is different from the source gateway name, use the format <plugin>:<source_gateway_name>",
+    )
+    @click.option(
+        "-n",
+        "--new-interface",
+        default=False,
+        is_flag=True,
+        help="Create a new gateway interface - supported only in plugin projects.",
+    )
+    def gateway(
+        name,
+        interface,
+        copy_from,
+        new_interface,
+    ):
+        """
+        Creates a template for a gateway.
+
+        name: Name of the component to create. Must be kebab-case. (don't add 'gateway' to the name)
+
+        If no interfaces is provided, a gateway from scratch will be created.
+        """
+        interface = list(interface)
+
+        if new_interface and interface:
+            log_error(
+                "Error: The --new-interface/-n flag is supported only when no interfaces are provided."
+            )
+            return 1
+        
+        if copy_from and interface:
+            log_error(
+                "Error: The --copy-from/-c flag is supported only when no interfaces are provided."
+            )
+        
+        # Copy from plugin
+        if copy_from:
+            return copy_from_plugin(name, copy_from, "gateways")
+        
+        # Creating a new gateway interface
+        if new_interface:
+            if not Config.is_plugin_project():
+                log_error(
+                    "Error: The --new-interface flag is supported only in plugin projects."
+                )
+                return 1
+            return add_interface_command(name)
+        
+        # Create a new gateway from an interface
+        return add_gateway_command(name, interface)

solace_agent_mesh/cli/commands/add/agent.py

@@ -0,0 +1,110 @@
+import os
+import click
+
+from cli.utils import get_display_path, load_template, log_error, get_formatted_names
+
+
+def add_agent_command(name):
+    """
+    Creates a template for an agent
+    """
+    # Name must be kebab-case, and only character, numbers, and hyphens are allowed
+    if not name.islower() or not name.replace("-", "").isalnum():
+        log_error(
+            "Error: Name must be kebab-case. Only lowercase letters, numbers, and hyphens are allowed.",
+        )
+        return 1
+
+    formatted_name = get_formatted_names(name)
+
+    try:
+        # Load the template file
+        template_file = load_template("agent.yaml", formatted_name)
+        if template_file is None:
+            log_error("Error: Template file for agent not found.")
+            return 1
+    except IOError as e:
+        log_error(f"Error reading template file: {e}")
+        return 1
+
+    config = click.get_current_context().obj
+    config_directory = config["solace_agent_mesh"]["config_directory"]
+
+    try:
+        file_name = f"{formatted_name['SNAKE_CASE_NAME']}.yaml"
+        directory = os.path.join(config_directory, "agents")
+        path = os.path.join(directory, file_name)
+
+        # Check if the file already exists
+        if os.path.exists(path):
+            overwrite = click.confirm(
+                f"File {path} already exists. Do you want to overwrite it?",
+                default=False,
+            )
+            if not overwrite:
+                click.echo("Template not created.")
+                return
+
+        # Create the directory if it doesn't exist
+        os.makedirs(directory, exist_ok=True)
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(template_file)
+    except IOError as e:
+        log_error(f"Error creating template: {e}")
+        return 1
+
+    click.echo(f"Created agent template at: {get_display_path(path)}")
+
+    try:
+        # Creating the agent file
+        agent_directory = os.path.join(
+            config["solace_agent_mesh"]["modules_directory"],
+            "agents",
+            formatted_name["SNAKE_CASE_NAME"],
+        )
+        # Create the agent directory
+        os.makedirs(agent_directory, exist_ok=True)
+        # Create the __init__.py file
+        init_file = os.path.join(agent_directory, "__init__.py")
+        if not os.path.exists(init_file):
+            with open(init_file, "w", encoding="utf-8") as f:
+                f.write("")
+
+        # Create the agent python file
+        agent_path = os.path.join(
+            agent_directory,
+            f"{formatted_name['SNAKE_CASE_NAME']}_agent_component.py",
+        )
+        agent_template = load_template("agent.py", formatted_name)
+        if not os.path.exists(agent_path):
+            with open(agent_path, "w", encoding="utf-8") as f:
+                f.write(agent_template)
+
+        click.echo(
+            f"Created agent at: {get_display_path(agent_path)}"
+        )
+
+        # Create the agent action
+        action_directory = os.path.join(agent_directory, "actions")
+        os.makedirs(action_directory, exist_ok=True)
+        # Create the __init__.py file
+        init_file = os.path.join(action_directory, "__init__.py")
+        if not os.path.exists(init_file):
+            with open(init_file, "w", encoding="utf-8") as f:
+                f.write("")
+
+        action_path = os.path.join(action_directory, "sample_action.py")
+        action_template = load_template("action.py", formatted_name)
+        if not os.path.exists(action_path):
+            with open(action_path, "w", encoding="utf-8") as f:
+                f.write(action_template)
+
+        click.echo(f"Created sample action at: {get_display_path(action_path)}")
+
+        temp_file = os.path.join(config_directory, "__TEMPLATES_WILL_BE_HERE__")
+        if os.path.exists(temp_file):
+            os.remove(temp_file)
+    except IOError as e:
+        log_error(f"Error creating agent, agent config was created: {e}")
+        return 1
+

solace_agent_mesh/cli/commands/add/copy_from_plugin.py

@@ -0,0 +1,90 @@
+import os
+import click
+
+from cli.utils import log_error, load_plugin, get_display_path, get_formatted_names
+
+
+def copy_from_plugin(name, plugin_name, entity_type):
+    """
+    Creates a template for an agent or gateway by copying from an existing plugin.
+
+    name: Name of the component to create.
+    plugin_name: Name of the plugin. This is either just the plugin or plugin:entity_name
+                 for cases where the source config name is different from the destination name
+    entity_type: Type of the entity to create. (agents or gateways)
+    """
+    if entity_type not in ["agents", "gateways"]:
+        log_error("Invalid entity type.")
+        return 1
+    
+    src_entity_name = name
+    if ":" in plugin_name:
+        plugin_name, src_entity_name = plugin_name.split(":")
+
+    plugin_name = plugin_name.replace("-", "_")
+    plugin_path = load_plugin(plugin_name, return_path_only=True)
+    if not plugin_path:
+        log_error(f"Could not find '{plugin_name}' installed.")
+        return 1
+
+    name_cases = get_formatted_names(name)
+
+    item_name = name.replace("-", "_")
+    item_name = f"{item_name}.yaml" if entity_type == "agents" else item_name
+
+    src_entity_name = src_entity_name.replace("-", "_")
+    src_entity_name = f"{src_entity_name}.yaml" if entity_type == "agents" else src_entity_name
+    template_path = os.path.join(plugin_path, "configs", entity_type, src_entity_name)
+
+    if not os.path.exists(template_path):
+        log_error(f"Could not find '{item_name}' in '{plugin_name}' plugin.")
+        return 1
+
+    config = click.get_current_context().obj
+    config_directory = config["solace_agent_mesh"]["config_directory"]
+    target_directory = os.path.join(config_directory, entity_type)
+    os.makedirs(target_directory, exist_ok=True)
+
+    def parse_file(content):
+        content = (
+            content.replace(" src.", f" {plugin_name}.src.")
+            .replace("{{MODULE_DIRECTORY}}", f"{plugin_name}.src")
+            .replace("src.src.", "src.")
+        )
+        for case, val in name_cases.items():
+            content = content.replace(f"{{{{{case}}}}}", val)
+
+        return content
+
+    if entity_type == "agents":
+        with open(template_path, "r", encoding="utf-8") as f:
+            template_file = parse_file(f.read())
+        target_path = os.path.join(target_directory, item_name)
+        with open(target_path, "w", encoding="utf-8") as f:
+            f.write(template_file)
+
+    elif entity_type == "gateways":
+        target_directory = os.path.join(target_directory, item_name)
+        os.makedirs(target_directory, exist_ok=True)
+
+        for file_item in os.listdir(template_path):
+            source_path = os.path.join(template_path, file_item)
+            if not os.path.isfile(source_path):
+                continue
+            with open(source_path, "r", encoding="utf-8") as f:
+                template_file = parse_file(f.read())
+            target_path = os.path.join(target_directory, file_item)
+            with open(target_path, "w", encoding="utf-8") as f:
+                f.write(template_file)
+
+    else:
+        log_error("Invalid entity type.")
+        return 1
+    
+    temp_file = os.path.join(config_directory, "__TEMPLATES_WILL_BE_HERE__")
+    if os.path.exists(temp_file):
+        os.remove(temp_file)
+        
+    click.echo(
+        f"Copied {entity_type[:-1]} '{name}' from plugin '{plugin_name}' at: {get_display_path(target_directory)}"
+    )

solace_agent_mesh/cli/commands/add/gateway.py

@@ -0,0 +1,221 @@
+import os
+import sys
+import click
+
+from cli.utils import get_display_path, load_template, log_error, get_formatted_names
+from cli.commands.plugin.build import get_all_plugin_gateway_interfaces
+from cli.config import Config
+
+def _add_python_files(modules_directory, template_args, created_file_names):
+    # Creating the python files
+    module_directory = os.path.join(
+        modules_directory,
+        "gateways",
+        template_args["SNAKE_CASE_NAME"],
+    )
+    # Create the gateway directory
+    os.makedirs(module_directory, exist_ok=True)
+    # Create the __init__.py file
+    init_file = os.path.join(module_directory, "__init__.py")
+    if not os.path.exists(init_file):
+        with open(init_file, "w", encoding="utf-8") as f:
+            f.write("")
+    created_file_names.append(init_file)
+
+    # Create the gateway python file
+    for gateways_file in ["base", "input", "output"]:
+        gateway_path = os.path.join(
+            module_directory,
+            f"{template_args['SNAKE_CASE_NAME']}_{gateways_file}.py",
+        )
+        gateway_template = load_template(f"gateway_{gateways_file}.py", template_args)
+        if not os.path.exists(gateway_path):
+            with open(gateway_path, "w", encoding="utf-8") as f:
+                f.write(gateway_template)
+        created_file_names.append(gateway_path)
+
+def add_gateway_command(name, interfaces):
+    """
+    Creates a gateway configuration directory and files based on provided templates.
+
+    This function performs the following steps:
+    1. Creates a directory for the gateway in the specified configuration directory.
+    2. Copies a gateway configuration template file to the new gateway directory.
+    3. If a list of interfaces is provided, creates configuration files for each interface based on corresponding templates.
+
+    Args:
+        interfaces (list): A list of interface names for which configuration files should be created.
+        formatted_name (dict): A dictionary containing the formatted name of the gateway.
+                               The key "SNAKE_CASE_NAME" is used to name the gateway directory.
+
+    Returns:
+        int: Returns 1 if an IOError occurs during the creation of the gateway configuration, otherwise returns None.
+
+    Raises:
+        IOError: If there is an error creating the gateway configuration files or directories.
+    """
+
+    # Name must be kebab-case, and only character, numbers, and hyphens are allowed
+    if not name.islower() or not name.replace("-", "").isalnum():
+        log_error(
+            "Error: Name must be kebab-case. Only lowercase letters, numbers, and hyphens are allowed.",
+        )
+        return 1
+
+    formatted_name = get_formatted_names(name)
+    created_file_names = []
+
+    try:
+        # Create a directory for the gateway in the config directory
+        config = click.get_current_context().obj["solace_agent_mesh"]
+        config_directory = config["config_directory"]
+        gateway_directory = os.path.join(
+            config_directory, "gateways", formatted_name["SNAKE_CASE_NAME"]
+        )
+
+        def abort():
+            sys.exit(1)
+
+        plugin_gateway_interfaces = get_all_plugin_gateway_interfaces(config, abort)
+
+        # Check if the gateway directory already exists
+        if os.path.exists(gateway_directory):
+            overwrite = click.confirm(
+                f"Gateway directory {gateway_directory} already exists. Do you want to overwrite it?",
+                default=False,
+            )
+            if not overwrite:
+                click.echo("Gateway template not created.")
+                return
+        os.makedirs(gateway_directory, exist_ok=True)
+
+        # Create the gateway config file from the template directory
+        # The file name is gateway-default-config.yaml but write it as gateway.yaml in the gateway_directory
+        gateway_config_template = load_template("gateway-default-config.yaml")
+        gateway_config_path = os.path.join(gateway_directory, "gateway.yaml")
+        with open(gateway_config_path, "w", encoding="utf-8") as f:
+            f.write(gateway_config_template)
+
+        created_file_names.append(gateway_config_path)
+
+        # If the interface list is not empty, create the interface config files
+        if interfaces:
+            for interface in interfaces:
+                # Load the interface template from the templates directory.
+                # The name will be {interface}-default-config.yaml
+                # Write the file as {interface}.yaml in the gateway_directory
+                if interface in plugin_gateway_interfaces:
+                    interface_default_path = os.path.join(
+                        plugin_gateway_interfaces[interface],
+                        f"{interface}-default-config.yaml",
+                    )
+                    if not os.path.exists(interface_default_path):
+                        log_error("Error: Interface template not found.")
+                        return 1
+                    with open(interface_default_path, "r", encoding="utf-8") as g:
+                        interface_template = g.read()
+                else:
+                    interface_template = load_template(
+                        f"{interface}-default-config.yaml"
+                    )
+                    if not interface_template:
+                        log_error("Error: Interface template not found.")
+                        return 1
+
+                interface_config_path = os.path.join(
+                    gateway_directory, f"{interface}.yaml"
+                )
+                with open(interface_config_path, "w", encoding="utf-8") as f:
+                    f.write(interface_template)
+
+                created_file_names.append(interface_config_path)
+
+        else:
+            click.echo(click.style("No interfaces provided. A gateway from scratch will be created.", fg="yellow"))
+            try:
+                # Create the gateway config file
+                interface_config_path = os.path.join(
+                    gateway_directory,
+                    f"{formatted_name['SNAKE_CASE_NAME']}.yaml",
+                )
+                gateway_template = load_template("gateway-config-template.yaml", formatted_name)
+                if not os.path.exists(interface_config_path):
+                    with open(interface_config_path, "w", encoding="utf-8") as f:
+                        f.write(gateway_template)
+                created_file_names.append(interface_config_path)
+
+                _add_python_files(config["modules_directory"], formatted_name, created_file_names)
+            except IOError as e:
+                log_error(f"Error creating gateway, gateway config was created: {e}")
+                return 1
+            
+        temp_file = os.path.join(config_directory, "__TEMPLATES_WILL_BE_HERE__")
+        if os.path.exists(temp_file):
+            os.remove(temp_file)
+
+    except IOError as e:
+        log_error(f"Error creating gateway config: {e}")
+        return 1
+    
+    finally:
+        if created_file_names:
+            click.echo("Created the following gateway template files:")
+            for file_name in created_file_names:
+                click.echo(f"  - {get_display_path(file_name)}")
+
+
+def add_interface_command(name):
+    """
+    Creates a new gateway interface with the provided name.
+    """
+    config = Config.get_plugin_config()
+    plugin_name = config.get("solace_agent_mesh_plugin", {}).get("name")
+    if not plugin_name or plugin_name == "solace-agent-mesh-plugin":
+        log_error("Could not find a valid plugin project")
+        return 1
+    
+    plugin_name = plugin_name.replace("-","_")
+    template_args = get_formatted_names(name)
+    template_args.update({
+        "MODULE_DIRECTORY": f"{plugin_name}.src"
+    })
+    created_file_names = []
+
+    interfaces_directory = os.path.join("interfaces")
+    modules_directory = os.path.join("src")
+
+    try:
+        os.makedirs(interfaces_directory, exist_ok=True)
+
+        temp_file = os.path.join(interfaces_directory, "__INTERFACES_WILL_BE_HERE__")
+        if os.path.exists(temp_file):
+            os.remove(temp_file)
+
+        # Create the interface flows and config file
+        interface_flows_path = os.path.join(interfaces_directory, f"{template_args['HYPHENED_NAME']}-flows.yaml")
+        interface_config_path = os.path.join(interfaces_directory, f"{template_args['HYPHENED_NAME']}-default-config.yaml")
+
+        interface_flows_template = load_template("gateway-flows.yaml", template_args)
+        interface_flows_template = interface_flows_template.replace(" src.gateway", " solace_agent_mesh.src.gateway")
+        if not os.path.exists(interface_flows_path):
+            with open(interface_flows_path, "w", encoding="utf-8") as f:
+                f.write(interface_flows_template)
+        created_file_names.append(interface_flows_path)
+
+        interface_config_template = load_template("gateway-config-template.yaml", template_args)
+        if not os.path.exists(interface_config_path):
+            with open(interface_config_path, "w", encoding="utf-8") as f:
+                f.write(interface_config_template)
+        created_file_names.append(interface_config_path)
+
+        _add_python_files(modules_directory, template_args, created_file_names)
+
+    except IOError as e:
+        log_error(f"Error creating gateway interface, {e}")
+        return 1
+    
+    finally:
+        if created_file_names:
+            click.echo("Created the following gateway template files:")
+            for file_name in created_file_names:
+                click.echo(f"  - {get_display_path(file_name)}")