agentex-sdk 0.1.0a6__py3-none-any.whl

agentex/lib/cli/commands/agents.py

@@ -0,0 +1,328 @@
+import builtins
+from pathlib import Path
+
+import questionary
+import typer
+from rich import print_json
+from rich.console import Console
+from rich.panel import Panel
+
+from agentex.lib.cli.handlers.agent_handlers import (
+    build_agent,
+    run_agent,
+)
+from agentex.lib.cli.handlers.cleanup_handlers import cleanup_agent_workflows
+from agentex.lib.cli.handlers.deploy_handlers import (
+    DeploymentError,
+    HelmError,
+    InputDeployOverrides,
+    deploy_agent,
+)
+from agentex.lib.cli.utils.cli_utils import handle_questionary_cancellation
+from agentex.lib.cli.utils.kubectl_utils import (
+    check_and_switch_cluster_context,
+    validate_namespace,
+)
+from agentex import Agentex
+from agentex.lib.sdk.config.agent_manifest import AgentManifest
+from agentex.lib.utils.logging import make_logger
+
+logger = make_logger(__name__)
+console = Console()
+
+agents = typer.Typer()
+
+
+@agents.command()
+def get(
+    agent_id: str = typer.Argument(..., help="ID of the agent to get"),
+):
+    """
+    Get the agent with the given name.
+    """
+    logger.info(f"Getting agent with ID: {agent_id}")
+    client = Agentex()
+    agent = client.agents.retrieve(agent_id=agent_id)
+    logger.info(f"Agent retrieved: {agent}")
+    print_json(data=agent.to_dict())
+
+
+@agents.command()
+def list():
+    """
+    List all agents.
+    """
+    logger.info("Listing all agents")
+    client = Agentex()
+    agents = client.agents.list()
+    logger.info(f"Agents retrieved: {agents}")
+    print_json(data=[agent.to_dict() for agent in agents])
+
+
+@agents.command()
+def delete(
+    agent_name: str = typer.Argument(..., help="Name of the agent to delete"),
+):
+    """
+    Delete the agent with the given name.
+    """
+    logger.info(f"Deleting agent with name: {agent_name}")
+    client = Agentex()
+    client.agents.delete_by_name(agent_name=agent_name)
+    logger.info(f"Agent deleted: {agent_name}")
+
+
+@agents.command()
+def cleanup_workflows(
+    agent_name: str = typer.Argument(..., help="Name of the agent to cleanup workflows for"),
+    force: bool = typer.Option(False, help="Force cleanup using direct Temporal termination (bypasses development check)"),
+):
+    """
+    Clean up all running workflows for an agent.
+    
+    By default, uses graceful cancellation via agent RPC.
+    With --force, directly terminates workflows via Temporal client.
+    This is a convenience command that does the same thing as 'agentex tasks cleanup'.
+    """
+    try:
+        console.print(f"[blue]Cleaning up workflows for agent '{agent_name}'...[/blue]")
+        
+        cleanup_agent_workflows(
+            agent_name=agent_name,
+            force=force,
+            development_only=True
+        )
+        
+        console.print(f"[green]✓ Workflow cleanup completed for agent '{agent_name}'[/green]")
+        
+    except Exception as e:
+        console.print(f"[red]Cleanup failed: {str(e)}[/red]")
+        logger.exception("Agent workflow cleanup failed")
+        raise typer.Exit(1) from e
+
+
+@agents.command()
+def build(
+    manifest: str = typer.Option(..., help="Path to the manifest you want to use"),
+    registry: str | None = typer.Option(
+        None, help="Registry URL for pushing the built image"
+    ),
+    repository_name: str | None = typer.Option(
+        None, help="Repository name to use for the built image"
+    ),
+    platforms: str | None = typer.Option(
+        None, help="Platform to build the image for. Please enter a comma separated list of platforms."
+    ),
+    push: bool = typer.Option(False, help="Whether to push the image to the registry"),
+    secret: str | None = typer.Option(
+        None,
+        help="Docker build secret in the format 'id=secret-id,src=path-to-secret-file'",
+    ),
+    tag: str | None = typer.Option(
+        None, help="Image tag to use (defaults to 'latest')"
+    ),
+    build_arg: builtins.list[str] | None = typer.Option(  # noqa: B008
+        None,
+        help="Docker build argument in the format 'KEY=VALUE' (can be used multiple times)",
+    ),
+):
+    """
+    Build an agent image locally from the given manifest.
+    """
+    typer.echo(f"Building agent image from manifest: {manifest}")
+
+    # Validate required parameters for building
+    if push and not registry:
+        typer.echo("Error: --registry is required when --push is enabled", err=True)
+        raise typer.Exit(1)
+    
+    # Only proceed with build if we have a registry (for now, to match existing behavior)
+    if not registry:
+        typer.echo("No registry provided, skipping image build")
+        return
+
+    platform_list = platforms.split(",") if platforms else []
+
+    try:
+        image_url = build_agent(
+            manifest_path=manifest,
+            registry_url=registry,  # Now guaranteed to be non-None
+            repository_name=repository_name or "default-repo",  # Provide default
+            platforms=platform_list,
+            push=push,
+            secret=secret or "",  # Provide default empty string
+            tag=tag or "latest",  # Provide default
+            build_args=build_arg or [],  # Provide default empty list
+        )
+        if image_url:
+            typer.echo(f"Successfully built image: {image_url}")
+        else:
+            typer.echo("Image build completed but no URL returned")
+    except Exception as e:
+        typer.echo(f"Error building agent image: {str(e)}", err=True)
+        logger.exception("Error building agent image")
+        raise typer.Exit(1) from e
+
+
+@agents.command()
+def run(
+    manifest: str = typer.Option(..., help="Path to the manifest you want to use"),
+    cleanup_on_start: bool = typer.Option(
+        False, 
+        help="Clean up existing workflows for this agent before starting"
+    ),
+):
+    """
+    Run an agent locally from the given manifest.
+    """
+    typer.echo(f"Running agent from manifest: {manifest}")
+    
+    # Optionally cleanup existing workflows before starting
+    if cleanup_on_start:
+        try:
+            # Parse manifest to get agent name
+            manifest_obj = AgentManifest.from_yaml(file_path=manifest)
+            agent_name = manifest_obj.agent.name
+            
+            console.print(f"[yellow]Cleaning up existing workflows for agent '{agent_name}'...[/yellow]")
+            cleanup_agent_workflows(
+                agent_name=agent_name,
+                force=False,
+                development_only=True
+            )
+            console.print("[green]✓ Pre-run cleanup completed[/green]")
+            
+        except Exception as e:
+            console.print(f"[yellow]⚠ Pre-run cleanup failed: {str(e)}[/yellow]")
+            logger.warning(f"Pre-run cleanup failed: {e}")
+    
+    try:
+        run_agent(manifest_path=manifest)
+    except Exception as e:
+        typer.echo(f"Error running agent: {str(e)}", err=True)
+        logger.exception("Error running agent")
+        raise typer.Exit(1) from e
+
+
+@agents.command()
+def deploy(
+    cluster: str = typer.Option(
+        ..., help="Target cluster name (must match kubectl context)"
+    ),
+    manifest: str = typer.Option("manifest.yaml", help="Path to the manifest file"),
+    namespace: str | None = typer.Option(
+        None,
+        help="Kubernetes namespace to deploy to (required in non-interactive mode)",
+    ),
+    tag: str | None = typer.Option(None, help="Override the image tag for deployment"),
+    repository: str | None = typer.Option(
+        None, help="Override the repository for deployment"
+    ),
+    override_file: str | None = typer.Option(
+        None, help="Path to override configuration file"
+    ),
+    interactive: bool = typer.Option(
+        True, "--interactive/--no-interactive", help="Enable interactive prompts"
+    ),
+):
+    """Deploy an agent to a Kubernetes cluster using Helm"""
+
+    console.print(
+        Panel.fit("🚀 [bold blue]Deploy Agent[/bold blue]", border_style="blue")
+    )
+
+    try:
+        # Validate manifest exists
+        manifest_path = Path(manifest)
+        if not manifest_path.exists():
+            console.print(f"[red]Error:[/red] Manifest file not found: {manifest}")
+            raise typer.Exit(1)
+
+        # In non-interactive mode, require namespace
+        if not interactive and not namespace:
+            console.print(
+                "[red]Error:[/red] --namespace is required in non-interactive mode"
+            )
+            raise typer.Exit(1)
+
+        # Get namespace if not provided (only in interactive mode)
+        if not namespace:
+            namespace = questionary.text(
+                "Enter Kubernetes namespace:", default="default"
+            ).ask()
+            namespace = handle_questionary_cancellation(namespace, "namespace input")
+
+            if not namespace:
+                console.print("Deployment cancelled")
+                raise typer.Exit(0)
+
+        # Validate override file exists if provided
+        if override_file:
+            override_path = Path(override_file)
+            if not override_path.exists():
+                console.print(
+                    f"[red]Error:[/red] Override file not found: {override_file}"
+                )
+                raise typer.Exit(1)
+
+        # Load manifest for credential validation
+        manifest_obj = AgentManifest.from_yaml(str(manifest_path))
+
+        # Confirm deployment (only in interactive mode)
+        console.print("\n[bold]Deployment Summary:[/bold]")
+        console.print(f"  Manifest: {manifest}")
+        console.print(f"  Cluster: {cluster}")
+        console.print(f"  Namespace: {namespace}")
+        if tag:
+            console.print(f"  Image Tag: {tag}")
+        if override_file:
+            console.print(f"  Override File: {override_file}")
+
+        if interactive:
+            proceed = questionary.confirm("Proceed with deployment?").ask()
+            proceed = handle_questionary_cancellation(
+                proceed, "deployment confirmation"
+            )
+
+            if not proceed:
+                console.print("Deployment cancelled")
+                raise typer.Exit(0)
+        else:
+            console.print("Proceeding with deployment (non-interactive mode)")
+
+        check_and_switch_cluster_context(cluster)
+        if not validate_namespace(namespace, cluster):
+            console.print(
+                f"[red]Error:[/red] Namespace '{namespace}' does not exist in cluster '{cluster}'"
+            )
+            raise typer.Exit(1)
+
+        deploy_overrides = InputDeployOverrides(repository=repository, image_tag=tag)
+
+        # Deploy agent
+        deploy_agent(
+            manifest_path=str(manifest_path),
+            cluster_name=cluster,
+            namespace=namespace,
+            deploy_overrides=deploy_overrides,
+            override_file_path=override_file,
+        )
+
+        # Use the already loaded manifest object
+        release_name = f"{manifest_obj.agent.name}-{cluster}"
+
+        console.print(
+            "\n[bold green]🎉 Deployment completed successfully![/bold green]"
+        )
+        console.print("\nTo check deployment status:")
+        console.print(f"  kubectl get pods -n {namespace}")
+        console.print(f"  helm status {release_name} -n {namespace}")
+
+    except (DeploymentError, HelmError) as e:
+        console.print(f"[red]Deployment failed:[/red] {str(e)}")
+        logger.exception("Deployment failed")
+        raise typer.Exit(1) from e
+    except Exception as e:
+        console.print(f"[red]Unexpected error:[/red] {str(e)}")
+        logger.exception("Unexpected error during deployment")
+        raise typer.Exit(1) from e

agentex/lib/cli/commands/init.py

@@ -0,0 +1,227 @@
+from enum import Enum
+from pathlib import Path
+
+import questionary
+from jinja2 import Environment, FileSystemLoader
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from agentex.lib.utils.logging import make_logger
+
+logger = make_logger(__name__)
+console = Console()
+
+# Get the templates directory relative to this file
+TEMPLATES_DIR = Path(__file__).parent.parent / "templates"
+
+
+class TemplateType(str, Enum):
+    TEMPORAL = "temporal"
+    DEFAULT = "default"
+    SYNC = "sync"
+
+
+def render_template(
+    template_path: str, context: dict, template_type: TemplateType
+) -> str:
+    """Render a template with the given context"""
+    env = Environment(loader=FileSystemLoader(TEMPLATES_DIR / template_type.value))
+    template = env.get_template(template_path)
+    return template.render(**context)
+
+
+def create_project_structure(
+    path: Path, context: dict, template_type: TemplateType, use_uv: bool
+):
+    """Create the project structure from templates"""
+    # Create project directory
+    project_dir: Path = path / context["project_name"]
+    project_dir.mkdir(parents=True, exist_ok=True)
+
+    # Create project/code directory
+    code_dir: Path = project_dir / "project"
+    code_dir.mkdir(parents=True, exist_ok=True)
+
+    # Create __init__.py
+    (code_dir / "__init__.py").touch()
+
+    # Define project files based on template type
+    project_files = {
+        TemplateType.TEMPORAL: ["acp.py", "workflow.py", "run_worker.py"],
+        TemplateType.DEFAULT: ["acp.py"],
+        TemplateType.SYNC: ["acp.py"],
+    }[template_type]
+
+    # Create project/code files
+    for template in project_files:
+        template_path = f"project/{template}.j2"
+        output_path = code_dir / template
+        output_path.write_text(render_template(template_path, context, template_type))
+
+    # Create root files
+    root_templates = {
+        ".dockerignore.j2": ".dockerignore",
+        "manifest.yaml.j2": "manifest.yaml",
+        "README.md.j2": "README.md",
+    }
+
+    # Add package management file based on uv choice
+    if use_uv:
+        root_templates["pyproject.toml.j2"] = "pyproject.toml"
+        root_templates["Dockerfile-uv.j2"] = "Dockerfile"
+    else:
+        root_templates["requirements.txt.j2"] = "requirements.txt"
+        root_templates["Dockerfile.j2"] = "Dockerfile"
+
+    for template, output in root_templates.items():
+        output_path = project_dir / output
+        output_path.write_text(render_template(template, context, template_type))
+
+    console.print(f"\n[green]✓[/green] Created project structure at: {project_dir}")
+
+
+def get_project_context(answers: dict, project_path: Path, manifest_root: Path) -> dict:
+    """Get the project context from user answers"""
+    # Use agent_directory_name as project_name
+    project_name = answers["agent_directory_name"].replace("-", "_")
+
+    # Now, this is actually the exact same as the project_name because we changed the build root to be ../
+    project_path_from_build_root = project_name
+
+    return {
+        **answers,
+        "project_name": project_name,
+        "workflow_class": "".join(
+            word.capitalize() for word in answers["agent_name"].split("-")
+        )
+        + "Workflow",
+        "workflow_name": answers["agent_name"],
+        "queue_name": project_name + "_queue",
+        "project_path_from_build_root": project_path_from_build_root,
+    }
+
+
+def init():
+    """Initialize a new agent project"""
+    console.print(
+        Panel.fit(
+            "🤖 [bold blue]Initialize New Agent Project[/bold blue]",
+            border_style="blue",
+        )
+    )
+
+    # Use a Rich table for template descriptions
+    table = Table(show_header=True, header_style="bold magenta")
+    table.add_column("Template", style="cyan", no_wrap=True)
+    table.add_column("Description", style="white")
+    table.add_row(
+        "[bold cyan]Agentic - ACP Only[/bold cyan]",
+        "A simple synchronous agent that handles tasks directly. Best for straightforward agents that don't need long-running operations.",
+    )
+    table.add_row(
+        "[bold cyan]Agentic - Temporal[/bold cyan]",
+        "An asynchronous agent powered by Temporal workflows. Best for agents that need to handle long-running tasks, retries, or complex state management.",
+    )
+    table.add_row(
+        "[bold cyan]Sync ACP[/bold cyan]",
+        "A synchronous agent that handles tasks directly. The difference is that this Sync ACP will be required to respond with the results in the same call as the input.Best for straightforward agents that don't need long-running operations.",
+    )
+    console.print()
+    console.print(table)
+    console.print()
+
+    def validate_agent_name(text: str) -> bool | str:
+        """Validate agent name follows required format"""
+        is_valid = len(text) >= 1 and text.replace("-", "").isalnum() and text.islower()
+        if not is_valid:
+            return "Invalid name. Use only lowercase letters, numbers, and hyphens. Examples: 'my-agent', 'newsbot'"
+        return True
+
+    # Gather project information
+    template_type = questionary.select(
+        "What type of template would you like to create?",
+        choices=[
+            {"name": "Agentic - ACP Only", "value": TemplateType.DEFAULT},
+            {"name": "Agentic - Temporal", "value": TemplateType.TEMPORAL},
+            {"name": "Sync ACP", "value": TemplateType.SYNC},
+        ],
+    ).ask()
+    if not template_type:
+        return
+
+    project_path = questionary.path(
+        "Where would you like to create your project?", default="."
+    ).ask()
+    if not project_path:
+        return
+
+    agent_name = questionary.text(
+        "What's your agent name? (letters, numbers, and hyphens only)",
+        validate=validate_agent_name,
+    ).ask()
+    if not agent_name:
+        return
+
+    agent_directory_name = questionary.text(
+        "What do you want to name the project folder for your agent?",
+        default=agent_name,
+    ).ask()
+    if not agent_directory_name:
+        return
+
+    description = questionary.text(
+        "Provide a brief description of your agent:", default="An AgentEx agent"
+    ).ask()
+    if not description:
+        return
+
+    use_uv = questionary.select(
+        "Would you like to use uv for package management?",
+        choices=[
+            {"name": "Yes (Recommended)", "value": True},
+            {"name": "No", "value": False},
+        ],
+    ).ask()
+
+    answers = {
+        "template_type": template_type,
+        "project_path": project_path,
+        "agent_name": agent_name,
+        "agent_directory_name": agent_directory_name,
+        "description": description,
+        "use_uv": use_uv,
+    }
+
+    # Derive all names from agent_directory_name and path
+    project_path = Path(answers["project_path"]).resolve()
+    manifest_root = Path("../../")
+
+    # Get project context
+    context = get_project_context(answers, project_path, manifest_root)
+    context["template_type"] = answers["template_type"].value
+    context["use_uv"] = answers["use_uv"]
+
+    # Create project structure
+    create_project_structure(
+        project_path, context, answers["template_type"], answers["use_uv"]
+    )
+
+    # Show next steps
+    console.print("\n[bold green]✨ Project created successfully![/bold green]")
+    console.print("\n[bold]Next steps:[/bold]")
+    console.print(f"1. cd {project_path}/{context['project_name']}")
+    console.print("2. Review and customize the generated files")
+    console.print("3. Update the container registry in manifest.yaml")
+
+    if answers["template_type"] == TemplateType.TEMPORAL:
+        console.print("4. Run locally:")
+        console.print("   agentex agents run --manifest manifest.yaml")
+    else:
+        console.print("4. Run locally:")
+        console.print("   agentex agents run --manifest manifest.yaml")
+
+    console.print("5. Deploy your agent:")
+    console.print(
+        "   agentex agents deploy --cluster your-cluster --namespace your-namespace"
+    )

agentex/lib/cli/commands/main.py

@@ -0,0 +1,33 @@
+import typer
+
+from agentex.lib.cli.commands.agents import agents
+from agentex.lib.cli.commands.init import init
+from agentex.lib.cli.commands.secrets import secrets
+from agentex.lib.cli.commands.tasks import tasks
+from agentex.lib.cli.commands.uv import uv
+
+# Create the main Typer application
+app = typer.Typer(
+    context_settings={"help_option_names": ["-h", "--help"], "max_content_width": 800},
+    pretty_exceptions_show_locals=False,
+    pretty_exceptions_enable=False,
+    add_completion=False,
+)
+
+# Add the subcommands
+app.add_typer(agents, name="agents", help="Get, list, run, build, and deploy agents")
+app.add_typer(tasks, name="tasks", help="Get, list, and delete tasks")
+app.add_typer(secrets, name="secrets", help="Sync, get, list, and delete secrets")
+app.add_typer(
+    uv, name="uv", help="Wrapper for uv command with AgentEx-specific enhancements"
+)
+
+# Add init command with documentation
+app.command(
+    help="Initialize a new agent project with a template",
+    epilog="Example: agentex init --template temporal my-agent",
+)(init)
+
+
+if __name__ == "__main__":
+    app()