pipefy-cli 0.3.0a1__py3-none-any.whl

pipefy_cli/commands/agent.py

@@ -0,0 +1,358 @@
+"""AI Agent operations (list, CRUD, logs, behavior validation)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import typer
+from pipefy_sdk import (
+    CreateAiAgentInput,
+    PipefyClient,
+    UpdateAiAgentInput,
+)
+from pipefy_sdk.ai_preflight import validate_ai_agent_behaviors_sdk
+from pipefy_sdk.behavior_placeholders import (
+    expand_behaviors_placeholders,
+    normalize_pipefy_ai_instruction_tokens,
+)
+from pydantic import ValidationError
+
+from pipefy_cli.commands._common import (
+    ID_POSITIONAL_CONTEXT_SETTINGS,
+    confirm_destructive,
+    parse_json_value,
+    resource_id_argument,
+    run_cli_command,
+)
+
+agent_app = typer.Typer(help="AI Agents (repo-scoped).", no_args_is_help=True)
+logs_app = typer.Typer(help="AI Agent execution logs.", no_args_is_help=True)
+agent_app.add_typer(logs_app, name="logs")
+
+
+def _parse_behaviors_json(raw: str) -> list[dict[str, Any]]:
+    parsed = parse_json_value(raw, "--behaviors")
+    if not isinstance(parsed, list):
+        raise typer.BadParameter("--behaviors must be a JSON array")
+    out = [b for b in parsed if isinstance(b, dict)]
+    if not out:
+        raise typer.BadParameter("--behaviors must contain at least one object")
+    return out
+
+
+def _raise_if_preflight_blocks(payload: dict[str, Any]) -> None:
+    if not payload.get("success"):
+        msg = payload.get("error") or payload.get("message") or "Validation failed"
+        raise typer.BadParameter(str(msg))
+    if not payload.get("valid"):
+        problems = payload.get("problems") or []
+        text = "\n".join(f"  - {p}" for p in problems) if problems else "(no details)"
+        raise typer.BadParameter(f"validate-behaviors failed:\n{text}")
+
+
+@agent_app.command("list")
+def agent_list(
+    ctx: typer.Context,
+    repo: str = typer.Option(..., "--repo", help="Pipe UUID (repoUuid)."),
+    json_out: bool = typer.Option(
+        False, "--json", "-j", help="Print machine-readable JSON to stdout."
+    ),
+) -> None:
+    """List AI agents for a pipe (``get_ai_agents``)."""
+
+    async def factory(client: PipefyClient):
+        agents = await client.get_ai_agents(repo)
+        return {"success": True, "agents": agents}
+
+    run_cli_command(ctx, json_out, factory)
+
+
+@agent_app.command("get", context_settings=ID_POSITIONAL_CONTEXT_SETTINGS)
+def agent_get(
+    ctx: typer.Context,
+    uuid: str = resource_id_argument(help="Agent UUID."),
+    json_out: bool = typer.Option(
+        False, "--json", "-j", help="Print machine-readable JSON to stdout."
+    ),
+) -> None:
+    """Fetch one AI agent (``get_ai_agent``)."""
+
+    async def factory(client: PipefyClient):
+        agent = await client.get_ai_agent(uuid)
+        return {"success": True, "agent": agent}
+
+    run_cli_command(ctx, json_out, factory)
+
+
+@agent_app.command("create")
+def agent_create(
+    ctx: typer.Context,
+    repo_uuid: str = typer.Option(..., "--repo-uuid", help="Pipe UUID."),
+    name: str = typer.Option(..., "--name", "-n", help="Agent display name."),
+    instruction: str = typer.Option(
+        ...,
+        "--instruction",
+        help="Agent-level instruction (token-normalized).",
+    ),
+    behaviors: str = typer.Option(
+        ...,
+        "--behaviors",
+        help="JSON array of behavior objects.",
+    ),
+    pipe: str = typer.Option(
+        ...,
+        "--pipe",
+        help="Numeric pipe id for validate-behaviors pre-flight.",
+    ),
+    data_sources: str | None = typer.Option(
+        None,
+        "--data-sources",
+        help="Optional JSON array of knowledge-source id strings.",
+    ),
+    strict_unknown: bool = typer.Option(
+        True,
+        "--strict/--no-strict",
+        help=(
+            "Pre-flight strictness: when --strict (default), unknown actionType values "
+            "block; with --no-strict they become warnings only."
+        ),
+    ),
+    json_out: bool = typer.Option(
+        False, "--json", "-j", help="Print machine-readable JSON to stdout."
+    ),
+) -> None:
+    """Create and configure an AI agent (``create_ai_agent`` + ``update_ai_agent`` chain)."""
+    behavior_list = _parse_behaviors_json(behaviors)
+    ds_raw = parse_json_value(data_sources, "--data-sources") if data_sources else None
+    data_source_ids: list[str] = []
+    if ds_raw is not None:
+        if not isinstance(ds_raw, list) or not all(isinstance(x, str) for x in ds_raw):
+            raise typer.BadParameter("--data-sources must be a JSON array of strings")
+        data_source_ids = list(ds_raw)
+
+    inst = normalize_pipefy_ai_instruction_tokens(instruction.strip())
+    try:
+        expanded = expand_behaviors_placeholders(behavior_list)
+        validated = CreateAiAgentInput(
+            name=name.strip(),
+            repo_uuid=repo_uuid.strip(),
+            instruction=inst,
+            behaviors=expanded,
+            data_source_ids=data_source_ids,
+        )
+    except ValidationError as exc:
+        raise typer.BadParameter(str(exc)) from exc
+
+    async def factory(client: PipefyClient):
+        pre = await validate_ai_agent_behaviors_sdk(
+            client,
+            pipe.strip(),
+            [b.model_dump(by_alias=True) for b in validated.behaviors],
+            strict_unknown_action_types=strict_unknown,
+        )
+        _raise_if_preflight_blocks(pre)
+        create_result = await client.create_ai_agent(validated)
+        agent_uuid = create_result["agent_uuid"]
+        update_input = UpdateAiAgentInput(
+            uuid=agent_uuid,
+            name=validated.name,
+            repo_uuid=validated.repo_uuid,
+            instruction=validated.instruction,
+            behaviors=validated.behaviors,
+            data_source_ids=validated.data_source_ids,
+        )
+        await client.update_ai_agent(update_input)
+        out: dict[str, Any] = {
+            "success": True,
+            "agent_uuid": agent_uuid,
+            "message": f"Created agent {agent_uuid}",
+        }
+        if pre.get("warnings"):
+            out["preflight"] = pre
+        return out
+
+    run_cli_command(ctx, json_out, factory)
+
+
+@agent_app.command("update")
+def agent_update(
+    ctx: typer.Context,
+    uuid: str = typer.Option(..., "--uuid", help="Agent UUID."),
+    name: str = typer.Option(..., "--name", "-n", help="Agent display name."),
+    repo_uuid: str = typer.Option(..., "--repo-uuid", help="Pipe UUID."),
+    instruction: str = typer.Option(
+        ..., "--instruction", help="Agent-level instruction."
+    ),
+    behaviors: str = typer.Option(
+        ..., "--behaviors", help="JSON array of behavior objects."
+    ),
+    pipe: str = typer.Option(
+        ...,
+        "--pipe",
+        help="Numeric pipe id for validate-behaviors pre-flight.",
+    ),
+    data_sources: str | None = typer.Option(
+        None,
+        "--data-sources",
+        help="Optional JSON array of knowledge-source id strings.",
+    ),
+    strict_unknown: bool = typer.Option(
+        True,
+        "--strict/--no-strict",
+        help=(
+            "Pre-flight strictness: --strict (default) blocks on unknown actionType "
+            "values; --no-strict converts them to warnings."
+        ),
+    ),
+    json_out: bool = typer.Option(False, "--json", "-j"),
+) -> None:
+    """Replace AI agent configuration (``update_ai_agent``)."""
+    behavior_list = _parse_behaviors_json(behaviors)
+    ds_raw = parse_json_value(data_sources, "--data-sources") if data_sources else None
+    data_source_ids: list[str] = []
+    if ds_raw is not None:
+        if not isinstance(ds_raw, list) or not all(isinstance(x, str) for x in ds_raw):
+            raise typer.BadParameter("--data-sources must be a JSON array of strings")
+        data_source_ids = list(ds_raw)
+
+    inst = normalize_pipefy_ai_instruction_tokens(instruction.strip())
+    try:
+        expanded = expand_behaviors_placeholders(behavior_list)
+        validated = UpdateAiAgentInput(
+            uuid=uuid.strip(),
+            name=name.strip(),
+            repo_uuid=repo_uuid.strip(),
+            instruction=inst,
+            behaviors=expanded,
+            data_source_ids=data_source_ids,
+        )
+    except ValidationError as exc:
+        raise typer.BadParameter(str(exc)) from exc
+
+    async def factory(client: PipefyClient):
+        pre = await validate_ai_agent_behaviors_sdk(
+            client,
+            pipe.strip(),
+            [b.model_dump(by_alias=True) for b in validated.behaviors],
+            strict_unknown_action_types=strict_unknown,
+        )
+        _raise_if_preflight_blocks(pre)
+        result = await client.update_ai_agent(validated)
+        if pre.get("warnings"):
+            return {**result, "preflight": pre}
+        return result
+
+    run_cli_command(ctx, json_out, factory)
+
+
+@agent_app.command("delete", context_settings=ID_POSITIONAL_CONTEXT_SETTINGS)
+def agent_delete(
+    ctx: typer.Context,
+    uuid: str = resource_id_argument(help="Agent UUID."),
+    yes: bool = typer.Option(
+        False, "--yes", "-y", help="Skip interactive confirmation."
+    ),
+    json_out: bool = typer.Option(False, "--json", "-j"),
+) -> None:
+    """Delete an AI agent (``delete_ai_agent``)."""
+    confirm_destructive(yes=yes, description=f"AI agent (UUID: {uuid})", verb="delete")
+
+    async def factory(client: PipefyClient):
+        return await client.delete_ai_agent(uuid)
+
+    run_cli_command(ctx, json_out, factory)
+
+
+@agent_app.command("toggle", context_settings=ID_POSITIONAL_CONTEXT_SETTINGS)
+def agent_toggle(
+    ctx: typer.Context,
+    uuid: str = resource_id_argument(help="Agent UUID."),
+    active: bool = typer.Option(
+        True,
+        "--active/--inactive",
+        help="Enable or disable the agent.",
+    ),
+    yes: bool = typer.Option(
+        False, "--yes", "-y", help="Skip confirmation when disabling."
+    ),
+    json_out: bool = typer.Option(False, "--json", "-j"),
+) -> None:
+    """Enable or disable an AI agent (``toggle_ai_agent_status``)."""
+    if not active:
+        confirm_destructive(
+            yes=yes,
+            description=f"AI agent (UUID: {uuid})",
+            verb="disable",
+        )
+
+    async def factory(client: PipefyClient):
+        return await client.toggle_ai_agent_status(uuid, active=active)
+
+    run_cli_command(ctx, json_out, factory)
+
+
+@logs_app.command("list")
+def agent_logs_list(
+    ctx: typer.Context,
+    repo: str = typer.Option(..., "--repo", help="Pipe UUID."),
+    first: int = typer.Option(30, "--first", help="Page size."),
+    after: str | None = typer.Option(None, "--after", help="Pagination cursor."),
+    status: str | None = typer.Option(
+        None, "--status", help="processing|failed|success"
+    ),
+    search: str | None = typer.Option(None, "--search", help="Free-text search."),
+    json_out: bool = typer.Option(False, "--json", "-j"),
+) -> None:
+    """List AI agent execution logs (``get_ai_agent_logs``)."""
+
+    async def factory(client: PipefyClient):
+        return await client.get_ai_agent_logs(
+            repo, first=first, after=after, status=status, search_term=search
+        )
+
+    run_cli_command(ctx, json_out, factory)
+
+
+@logs_app.command("get", context_settings=ID_POSITIONAL_CONTEXT_SETTINGS)
+def agent_logs_get(
+    ctx: typer.Context,
+    log_id: str = resource_id_argument(help="Log UUID."),
+    json_out: bool = typer.Option(False, "--json", "-j"),
+) -> None:
+    """Fetch one AI agent log entry (``get_ai_agent_log_details``)."""
+
+    async def factory(client: PipefyClient):
+        return await client.get_ai_agent_log_details(log_id)
+
+    run_cli_command(ctx, json_out, factory)
+
+
+@agent_app.command("validate-behaviors")
+def agent_validate_behaviors(
+    ctx: typer.Context,
+    pipe: str = typer.Option(..., "--pipe", help="Numeric pipe id."),
+    behaviors: str = typer.Option(
+        ..., "--behaviors", help="JSON array of behavior objects."
+    ),
+    strict_unknown: bool = typer.Option(
+        True,
+        "--strict/--no-strict",
+        help=(
+            "Pre-flight strictness: --strict (default) reports unknown actionType "
+            "values as problems; --no-strict reports them as warnings only."
+        ),
+    ),
+    json_out: bool = typer.Option(False, "--json", "-j"),
+) -> None:
+    """Dry-run behavior validation (``validate_ai_agent_behaviors``)."""
+    behavior_list = _parse_behaviors_json(behaviors)
+
+    async def factory(client: PipefyClient):
+        return await validate_ai_agent_behaviors_sdk(
+            client,
+            pipe.strip(),
+            behavior_list,
+            strict_unknown_action_types=strict_unknown,
+        )
+
+    run_cli_command(ctx, json_out, factory)

pipefy_cli/commands/ai_automation.py

@@ -0,0 +1,318 @@
+"""AI Automations (generate_with_ai) via Internal API."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import typer
+from pipefy_sdk import (
+    CreateAiAutomationInput,
+    PipefyClient,
+    UpdateAiAutomationInput,
+)
+from pipefy_sdk.ai_preflight import (
+    filter_ai_automation_summaries,
+    validate_ai_automation_prompt_sdk,
+)
+from pydantic import ValidationError
+
+from pipefy_cli.commands._common import (
+    ID_POSITIONAL_CONTEXT_SETTINGS,
+    confirm_destructive,
+    parse_json_object,
+    parse_json_value,
+    resource_id_argument,
+    run_cli_command,
+)
+
+ai_automation_app = typer.Typer(
+    help="AI Automations (generate_with_ai).",
+    no_args_is_help=True,
+)
+
+
+def _raise_if_prompt_preflight_blocks(payload: dict[str, Any]) -> None:
+    if not payload.get("success"):
+        raise typer.BadParameter(str(payload.get("error") or "validate-prompt failed"))
+    if not payload.get("valid"):
+        problems = payload.get("problems") or []
+        text = "\n".join(f"  - {p}" for p in problems) if problems else "(no details)"
+        raise typer.BadParameter(f"validate-prompt failed:\n{text}")
+
+
+def _parse_field_ids(raw: str) -> list[str]:
+    parsed = parse_json_value(raw, "--field-ids")
+    if not isinstance(parsed, list) or not all(isinstance(x, str) for x in parsed):
+        raise typer.BadParameter("--field-ids must be a JSON array of strings")
+    return list(parsed)
+
+
+def _extract_existing_prompt_and_field_ids(
+    row: dict[str, Any],
+) -> tuple[str | None, list[str] | None]:
+    """Return ``(prompt, field_ids)`` from a ``generate_with_ai`` automation row.
+
+    Returns ``(None, None)`` for non-AI rows or rows missing the ``aiParams`` block;
+    callers must surface that as a clear user error.
+    """
+    action_params = row.get("action_params") or row.get("actionParams") or {}
+    ai_params = action_params.get("aiParams") or action_params.get("ai_params") or {}
+    prompt = ai_params.get("value")
+    field_ids = ai_params.get("fieldIds") or ai_params.get("field_ids")
+    if not isinstance(prompt, str):
+        prompt = None
+    if isinstance(field_ids, list) and all(isinstance(x, str) for x in field_ids):
+        return prompt, list(field_ids)
+    return prompt, None
+
+
+@ai_automation_app.command("list")
+def ai_automation_list(
+    ctx: typer.Context,
+    pipe: str = typer.Option(..., "--pipe", help="Pipe id."),
+    organization: str | None = typer.Option(
+        None, "--organization", "--org", help="Optional organization id."
+    ),
+    json_out: bool = typer.Option(False, "--json", "-j"),
+) -> None:
+    """List AI automations for a pipe (``get_ai_automations`` / filtered ``get_automations``)."""
+
+    async def factory(client: PipefyClient):
+        rows = await client.get_automations(
+            organization_id=organization,
+            pipe_id=pipe,
+        )
+        filtered = filter_ai_automation_summaries(rows or [])
+        return {"success": True, "data": filtered, "message": "AI automations listed."}
+
+    run_cli_command(ctx, json_out, factory)
+
+
+@ai_automation_app.command("get", context_settings=ID_POSITIONAL_CONTEXT_SETTINGS)
+def ai_automation_get(
+    ctx: typer.Context,
+    automation_id: str = resource_id_argument(help="Automation rule id."),
+    json_out: bool = typer.Option(False, "--json", "-j"),
+) -> None:
+    """Load one automation row (``get_ai_automation`` / ``get_automation``)."""
+
+    async def factory(client: PipefyClient):
+        row = await client.get_automation(automation_id)
+        if row is None:
+            return {
+                "success": False,
+                "message": "No automation found for the given ID.",
+            }
+        return {"success": True, "message": "AI automation retrieved.", "data": row}
+
+    run_cli_command(ctx, json_out, factory)
+
+
+@ai_automation_app.command("validate-prompt")
+def ai_automation_validate_prompt(
+    ctx: typer.Context,
+    pipe: str = typer.Option(..., "--pipe", help="Pipe id."),
+    prompt: str = typer.Option(
+        ..., "--prompt", help="Prompt with %{internal_id} tokens."
+    ),
+    field_ids: str = typer.Option(
+        ..., "--field-ids", help="JSON array of output field internal ids."
+    ),
+    event_id: str | None = typer.Option(
+        None,
+        "--event-id",
+        help="Optional trigger id to validate against the pipe catalog.",
+    ),
+    json_out: bool = typer.Option(False, "--json", "-j"),
+) -> None:
+    """Pre-flight prompt validation (``validate_ai_automation_prompt``)."""
+    fids = _parse_field_ids(field_ids)
+
+    async def factory(client: PipefyClient):
+        return await validate_ai_automation_prompt_sdk(
+            client, pipe.strip(), prompt, fids, event_id
+        )
+
+    run_cli_command(ctx, json_out, factory)
+
+
+@ai_automation_app.command("create")
+def ai_automation_create(
+    ctx: typer.Context,
+    pipe: str = typer.Option(..., "--pipe", help="Pipe id."),
+    name: str = typer.Option(..., "--name", "-n", help="Automation name."),
+    event_id: str = typer.Option(..., "--event-id", help="Trigger event id."),
+    prompt: str = typer.Option(
+        ..., "--prompt", help="AI prompt with %{internal_id} refs."
+    ),
+    field_ids: str = typer.Option(
+        ..., "--field-ids", help="JSON array of output field ids."
+    ),
+    action_repo: str | None = typer.Option(
+        None, "--action-repo", help="Optional action repo id (defaults to --pipe)."
+    ),
+    skills_ids: str | None = typer.Option(
+        None, "--skills-ids", help="Optional JSON array of skill id strings."
+    ),
+    event_params: str | None = typer.Option(
+        None, "--event-params", help="Optional JSON object."
+    ),
+    condition: str | None = typer.Option(
+        None, "--condition", help="Optional JSON object (omit for default placeholder)."
+    ),
+    json_out: bool = typer.Option(False, "--json", "-j"),
+) -> None:
+    """Create an AI automation (``create_ai_automation``)."""
+    fids = _parse_field_ids(field_ids)
+    ep = parse_json_object(event_params, "--event-params")
+    cond = parse_json_object(condition, "--condition")
+    skills_raw = parse_json_value(skills_ids, "--skills-ids") if skills_ids else None
+    skills: list[str] = []
+    if skills_raw is not None:
+        if not isinstance(skills_raw, list) or not all(
+            isinstance(x, str) for x in skills_raw
+        ):
+            raise typer.BadParameter("--skills-ids must be a JSON array of strings")
+        skills = list(skills_raw)
+
+    async def factory(client: PipefyClient):
+        pre = await validate_ai_automation_prompt_sdk(
+            client, pipe.strip(), prompt, fids, event_id
+        )
+        _raise_if_prompt_preflight_blocks(pre)
+        try:
+            kwargs: dict[str, Any] = {
+                "name": name.strip(),
+                "event_id": event_id.strip(),
+                "pipe_id": pipe.strip(),
+                "action_repo_id": action_repo.strip() if action_repo else None,
+                "prompt": prompt,
+                "field_ids": fids,
+                "skills_ids": skills,
+            }
+            if ep is not None:
+                kwargs["event_params"] = ep
+            if cond is not None:
+                kwargs["condition"] = cond
+            inp = CreateAiAutomationInput(**kwargs)
+        except ValidationError as exc:
+            raise typer.BadParameter(str(exc)) from exc
+        return await client.create_ai_automation(inp)
+
+    run_cli_command(ctx, json_out, factory)
+
+
+@ai_automation_app.command("update", context_settings=ID_POSITIONAL_CONTEXT_SETTINGS)
+def ai_automation_update(
+    ctx: typer.Context,
+    automation_id: str = resource_id_argument(help="Automation rule id."),
+    pipe: str = typer.Option(
+        ...,
+        "--pipe",
+        help="Pipe id for validate-prompt pre-flight.",
+    ),
+    prompt: str | None = typer.Option(
+        None,
+        "--prompt",
+        help="New prompt; omit to keep the current value (re-used in pre-flight).",
+    ),
+    field_ids: str | None = typer.Option(
+        None,
+        "--field-ids",
+        help=(
+            "JSON array of output field ids; omit to keep the current values "
+            "(re-used in pre-flight)."
+        ),
+    ),
+    name: str | None = typer.Option(None, "--name", "-n"),
+    patch_active: bool | None = typer.Option(
+        None,
+        "--patch-active/--no-patch-active",
+        help="Toggle the enabled flag; omit both flags to leave unchanged.",
+    ),
+    skills_ids: str | None = typer.Option(None, "--skills-ids"),
+    event_params: str | None = typer.Option(None, "--event-params"),
+    condition: str | None = typer.Option(None, "--condition"),
+    json_out: bool = typer.Option(False, "--json", "-j"),
+) -> None:
+    """Update an AI automation (``update_ai_automation``).
+
+    ``--prompt`` and ``--field-ids`` are optional: when omitted the CLI reads
+    the current values from the existing automation and re-uses them for the
+    ``validate_ai_automation_prompt`` pre-flight. Only fields you pass
+    explicitly are sent in the patch.
+    """
+    fids: list[str] | None = _parse_field_ids(field_ids) if field_ids else None
+    ep = parse_json_object(event_params, "--event-params")
+    cond = parse_json_object(condition, "--condition")
+    skills_raw = parse_json_value(skills_ids, "--skills-ids") if skills_ids else None
+    skills: list[str] | None = None
+    if skills_raw is not None:
+        if not isinstance(skills_raw, list) or not all(
+            isinstance(x, str) for x in skills_raw
+        ):
+            raise typer.BadParameter("--skills-ids must be a JSON array of strings")
+        skills = list(skills_raw)
+
+    async def factory(client: PipefyClient):
+        row = await client.get_automation(automation_id)
+        if row is None:
+            return {"success": False, "message": "Automation not found."}
+        existing_prompt, existing_fids = _extract_existing_prompt_and_field_ids(row)
+        effective_prompt = prompt if prompt is not None else existing_prompt
+        effective_fids = fids if fids is not None else existing_fids
+        if not effective_prompt or not effective_fids:
+            raise typer.BadParameter(
+                "Could not infer current prompt / field_ids from the existing automation. "
+                "Pass --prompt and --field-ids explicitly."
+            )
+        ev = str(row.get("event_id") or row.get("eventId") or "")
+        pre = await validate_ai_automation_prompt_sdk(
+            client,
+            pipe.strip(),
+            effective_prompt,
+            effective_fids,
+            ev or None,
+        )
+        _raise_if_prompt_preflight_blocks(pre)
+        try:
+            kwargs_u: dict[str, Any] = {
+                "automation_id": str(automation_id).strip(),
+                "name": name.strip() if name else None,
+                "active": patch_active,
+                "skills_ids": skills,
+            }
+            if prompt is not None:
+                kwargs_u["prompt"] = prompt
+            if fids is not None:
+                kwargs_u["field_ids"] = fids
+            if ep is not None:
+                kwargs_u["event_params"] = ep
+            if cond is not None:
+                kwargs_u["condition"] = cond
+            inp = UpdateAiAutomationInput(**kwargs_u)
+        except ValidationError as exc:
+            raise typer.BadParameter(str(exc)) from exc
+        return await client.update_ai_automation(inp)
+
+    run_cli_command(ctx, json_out, factory)
+
+
+@ai_automation_app.command("delete", context_settings=ID_POSITIONAL_CONTEXT_SETTINGS)
+def ai_automation_delete(
+    ctx: typer.Context,
+    automation_id: str = resource_id_argument(help="Automation rule id."),
+    yes: bool = typer.Option(
+        False, "--yes", "-y", help="Skip interactive confirmation."
+    ),
+    json_out: bool = typer.Option(False, "--json", "-j"),
+) -> None:
+    """Delete an AI automation (``delete_ai_automation`` / ``delete_automation``)."""
+    confirm_destructive(
+        yes=yes, description=f"AI automation {automation_id}", verb="delete"
+    )
+
+    async def factory(client: PipefyClient):
+        return await client.delete_automation(automation_id)
+
+    run_cli_command(ctx, json_out, factory)