lucius-mcp 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

src/tools/__init__.py

@@ -1,11 +1,15 @@
 from collections.abc import Awaitable, Callable
 
+from src.tools.create_custom_field_value import create_custom_field_value
 from src.tools.create_test_case import create_test_case
+from src.tools.delete_custom_field_value import delete_custom_field_value
 from src.tools.delete_test_case import delete_test_case
 from src.tools.get_custom_fields import get_custom_fields
 from src.tools.get_test_case_custom_fields import get_test_case_custom_fields
-from src.tools.launches import create_launch, list_launches
+from src.tools.launches import create_launch, get_launch, list_launches
 from src.tools.link_shared_step import link_shared_step
+from src.tools.list_custom_field_values import list_custom_field_values
+from src.tools.list_integrations import list_integrations
 from src.tools.search import get_test_case_details, list_test_cases, search_test_cases
 from src.tools.shared_steps import create_shared_step, delete_shared_step, list_shared_steps, update_shared_step
 from src.tools.test_layers import (
@@ -19,22 +23,28 @@ from src.tools.test_layers import (
     update_test_layer_schema,
 )
 from src.tools.unlink_shared_step import unlink_shared_step
+from src.tools.update_custom_field_value import update_custom_field_value
 from src.tools.update_test_case import update_test_case
 
 __all__ = [
+    "create_custom_field_value",
     "create_launch",
     "create_shared_step",
     "create_test_case",
     "create_test_layer",
     "create_test_layer_schema",
+    "delete_custom_field_value",
     "delete_shared_step",
     "delete_test_case",
     "delete_test_layer",
     "delete_test_layer_schema",
     "get_custom_fields",
+    "get_launch",
     "get_test_case_custom_fields",
     "get_test_case_details",
     "link_shared_step",
+    "list_custom_field_values",
+    "list_integrations",
     "list_launches",
     "list_shared_steps",
     "list_test_cases",
@@ -42,6 +52,7 @@ __all__ = [
     "list_test_layers",
     "search_test_cases",
     "unlink_shared_step",
+    "update_custom_field_value",
     "update_shared_step",
     "update_test_case",
     "update_test_layer",
@@ -57,10 +68,17 @@ all_tools: list[ToolFn] = [
     delete_test_case,
     list_test_cases,
     get_custom_fields,
+    list_custom_field_values,
+    create_custom_field_value,
+    update_custom_field_value,
+    delete_custom_field_value,
     get_test_case_custom_fields,
     search_test_cases,
     create_launch,
+    get_launch,
     list_launches,
+    # Integration Tools
+    list_integrations,
     create_shared_step,
     list_shared_steps,
     update_shared_step,

src/tools/create_custom_field_value.py

@@ -0,0 +1,38 @@
+from typing import Annotated
+
+from pydantic import Field
+
+from src.client import AllureClient
+from src.services.custom_field_value_service import CustomFieldValueService
+
+
+async def create_custom_field_value(
+    name: Annotated[str, Field(description="Name for the new custom field value.")],
+    custom_field_id: Annotated[
+        int | None,
+        Field(description="Project-scoped custom field ID to create a value for."),
+    ] = None,
+    custom_field_name: Annotated[
+        str | None,
+        Field(description="Custom field name to resolve when custom_field_id is not provided."),
+    ] = None,
+    project_id: Annotated[int | None, Field(description="Optional override for the default Project ID.")] = None,
+) -> str:
+    """Create a new custom field value option.
+
+    Args:
+        name: Name for the new custom field value.
+        custom_field_id: Project-scoped custom field ID to create a value for.
+        custom_field_name: Custom field name to resolve when custom_field_id is not provided.
+        project_id: Optional override for the default Project ID.
+    """
+    async with AllureClient.from_env(project=project_id) as client:
+        service = CustomFieldValueService(client=client)
+        created = await service.create_custom_field_value(
+            project_id=project_id,
+            custom_field_id=custom_field_id,
+            custom_field_name=custom_field_name,
+            name=name,
+        )
+
+        return f"✅ Custom field value created successfully!\nID: {created.id}\nName: {created.name}"

src/tools/create_test_case.py

@@ -53,6 +53,28 @@ async def create_test_case(
             )
         ),
     ] = None,
+    issues: Annotated[
+        list[str] | None,
+        Field(description="Optional list of issue keys to link (e.g., ['PROJ-123'])."),
+    ] = None,
+    integration_id: Annotated[
+        int | None,
+        Field(
+            description=(
+                "Optional integration ID for issue linking (use list_integrations to find IDs). "
+                "Required when multiple integrations exist. Mutually exclusive with integration_name."
+            )
+        ),
+    ] = None,
+    integration_name: Annotated[
+        str | None,
+        Field(
+            description=(
+                "Optional integration name for issue linking (exact case-sensitive match). "
+                "Required when multiple integrations exist. Mutually exclusive with integration_id."
+            )
+        ),
+    ] = None,
     project_id: Annotated[int | None, Field(description="Optional override for the default Project ID.")] = None,
 ) -> str:
     """Create a new test case in Allure TestOps.
@@ -69,8 +91,10 @@ async def create_test_case(
                                     'content_type': 'application/pdf'}]
         custom_fields: Dictionary of custom field names and their values (string or list of strings).
                        Example: {'Layer': 'UI', 'Components': ['Auth', 'DB']}
-        test_layer_id: Optional test layer ID to assign (must exist in the project).
         test_layer_name: Optional test layer name to assign (exact case-sensitive match).
+        issues: Optional list of issue keys to link (e.g., ['PROJ-123']).
+        integration_id: Optional integration ID for issue linking (required when multiple integrations exist).
+        integration_name: Optional integration name for issue linking (mutually exclusive with integration_id).
         project_id: Optional override for the default Project ID.
 
     Returns:
@@ -91,5 +115,11 @@ async def create_test_case(
             custom_fields=custom_fields,
             test_layer_id=test_layer_id,
             test_layer_name=test_layer_name,
+            issues=issues,
+            integration_id=integration_id,
+            integration_name=integration_name,
         )
-        return f"Created Test Case ID: {result.id} Name: {result.name}"
+        msg = f"Created Test Case ID: {result.id} Name: {result.name}"
+        if issues:
+            msg += f" with {len(issues)} linked issues: {', '.join(issues)}"
+        return msg

src/tools/delete_custom_field_value.py

@@ -0,0 +1,57 @@
+from typing import Annotated
+
+from pydantic import Field
+
+from src.client import AllureClient
+from src.services.custom_field_value_service import CustomFieldValueService
+
+
+async def delete_custom_field_value(
+    cfv_id: Annotated[int, Field(description="Custom field value ID to delete.")],
+    custom_field_id: Annotated[
+        int | None,
+        Field(description="Project-scoped custom field ID (optional, resolves by name if missing)."),
+    ] = None,
+    custom_field_name: Annotated[
+        str | None,
+        Field(description="Custom field name to resolve when custom_field_id is not provided."),
+    ] = None,
+    project_id: Annotated[int | None, Field(description="Optional override for the default Project ID.")] = None,
+    confirm: Annotated[
+        bool, Field(description="Must be set to True to proceed with deletion. Safety measure.")
+    ] = False,
+) -> str:
+    """Delete a custom field value.
+    ⚠️ CAUTION: Destructive.
+
+    Args:
+        cfv_id: Custom field value ID to delete.
+        custom_field_id: Project-scoped custom field ID (optional, resolves by name if missing).
+        custom_field_name: Custom field name to resolve when custom_field_id is not provided.
+        project_id: Optional Allure TestOps project ID override.
+        confirm: Must be set to True to proceed with deletion.
+            This is a safety measure to prevent accidental deletions.
+
+    Returns:
+        Confirmation message.
+    """
+    if not confirm:
+        return (
+            "⚠️ Deletion requires confirmation.\n\n"
+            "Deleting a custom field value may fail if it is currently in use. "
+            f"Please call again with confirm=True to proceed with deleting custom field value {cfv_id}."
+        )
+
+    async with AllureClient.from_env(project=project_id) as client:
+        service = CustomFieldValueService(client=client)
+        deleted = await service.delete_custom_field_value(
+            project_id=project_id,
+            cfv_id=cfv_id,
+            custom_field_id=custom_field_id,
+            custom_field_name=custom_field_name,
+        )
+
+        if deleted:
+            return f"✅ Custom field value {cfv_id} deleted successfully!"
+
+        return f"[INFO] Custom field value {cfv_id} was already removed."

src/tools/delete_test_case.py

@@ -16,6 +16,7 @@ async def delete_test_case(
     project_id: Annotated[int | None, Field(description="Optional Allure TestOps project ID override.")] = None,
 ) -> str:
     """Archive an obsolete test case.
+    ⚠️ CAUTION: Destructive.
 
     This performs a SOFT DELETE (archive). The test case can typically
     be recovered from the Allure UI if needed.
@@ -24,11 +25,11 @@ async def delete_test_case(
     Historical data and launch associations may be affected.
 
     Args:
-        test_case_id: The Allure test case ID to archive (required).
+        test_case_id: The Allure test case ID to archive.
             Found in the URL: /testcase/12345 -> test_case_id=12345
         confirm: Must be set to True to proceed with deletion.
             This is a safety measure to prevent accidental deletions.
-        project_id: Optional override for the default Project ID.
+        project_id: Optional Allure TestOps project ID override.
 
     Returns:
         Confirmation message with the archived test case details.
@@ -36,8 +37,8 @@ async def delete_test_case(
     if not confirm:
         return (
             "⚠️ Deletion requires confirmation.\n\n"
-            "Please call again with confirm=True to proceed with archiving "
-            f"test case {test_case_id}."
+            "Archiving test cases removes them from active views. "
+            f"Please call again with confirm=True to proceed with archiving test case {test_case_id}."
         )
 
     async with AllureClient.from_env(project=project_id) as client:

src/tools/delete_test_layer.py

@@ -11,16 +11,29 @@ from src.services.test_layer_service import TestLayerService
 async def delete_test_layer(
     layer_id: Annotated[int, Field(description="ID of the test layer to delete.")],
     project_id: Annotated[int | None, Field(description="Allure TestOps project ID.")] = None,
+    confirm: Annotated[
+        bool, Field(description="Must be set to True to proceed with deletion. Safety measure.")
+    ] = False,
 ) -> str:
     """Delete a test layer from Allure TestOps.
+    ⚠️ CAUTION: Destructive.
 
     Args:
-        layer_id: ID of the test layer to delete
-        project_id: Optional project ID override
+        layer_id: ID of the test layer to delete.
+        project_id: Optional Allure TestOps project ID override.
+        confirm: Must be set to True to proceed with deletion.
+            This is a safety measure to prevent accidental deletions.
 
     Returns:
-        Confirmation message
+        Confirmation message.
     """
+    if not confirm:
+        return (
+            "⚠️ Deletion requires confirmation.\n\n"
+            "Deleting a test layer may affect test case categorization. "
+            f"Please call again with confirm=True to proceed with deleting test layer {layer_id}."
+        )
+
     async with AllureClient.from_env(project=project_id) as client:
         service = TestLayerService(client)
         deleted = await service.delete_test_layer(layer_id=layer_id)
@@ -28,4 +41,4 @@ async def delete_test_layer(
     if deleted:
         return f"✅ Test layer {layer_id} deleted successfully!"
     else:
-        return f"[INFO] Test layer {layer_id} was already deleted or doesn't exist - no action taken."
+        return f"ℹ️ Test layer {layer_id} was already deleted or doesn't exist."  # noqa: RUF001

src/tools/delete_test_layer_schema.py

@@ -11,16 +11,29 @@ from src.services.test_layer_service import TestLayerService
 async def delete_test_layer_schema(
     schema_id: Annotated[int, Field(description="ID of the test layer schema to delete.")],
     project_id: Annotated[int | None, Field(description="Allure TestOps project ID.")] = None,
+    confirm: Annotated[
+        bool, Field(description="Must be set to True to proceed with deletion. Safety measure.")
+    ] = False,
 ) -> str:
     """Delete a test layer schema from the project.
+    ⚠️ CAUTION: Destructive.
 
     Args:
-        schema_id: ID of the schema to delete
-        project_id: Optional project ID override
+        schema_id: ID of the schema to delete.
+        project_id: Optional Allure TestOps project ID override.
+        confirm: Must be set to True to proceed with deletion.
+            This is a safety measure to prevent accidental deletions.
 
     Returns:
-        Confirmation message
+        Confirmation message.
     """
+    if not confirm:
+        return (
+            "⚠️ Deletion requires confirmation.\n\n"
+            "Deleting a schema removes the mapping between custom fields and layers. "
+            f"Please call again with confirm=True to proceed with deleting test layer schema {schema_id}."
+        )
+
     async with AllureClient.from_env(project=project_id) as client:
         service = TestLayerService(client)
         deleted = await service.delete_test_layer_schema(schema_id=schema_id)
@@ -28,4 +41,4 @@ async def delete_test_layer_schema(
     if deleted:
         return f"✅ Test layer schema {schema_id} deleted successfully!"
     else:
-        return f"[INFO] Test layer schema {schema_id} was already deleted or doesn't exist - no action taken."
+        return f"ℹ️ Test layer schema {schema_id} was already deleted or doesn't exist."  # noqa RUF001

src/tools/launches.py

@@ -6,6 +6,8 @@ from pydantic import Field
 
 from src.client import AllureClient
 from src.services.launch_service import LaunchListResult, LaunchService
+from src.utils.auth import get_auth_context
+from src.utils.config import settings
 
 
 async def create_launch(
@@ -88,6 +90,35 @@ async def list_launches(
     return _format_launch_list(result)
 
 
+async def get_launch(
+    launch_id: Annotated[int, Field(description="Launch ID (required).")],
+    project_id: Annotated[int | None, Field(description="Optional override for the default Project ID.")] = None,
+) -> str:
+    """Retrieve a specific launch and summarize its details.
+
+    Args:
+        launch_id: The unique ID of the launch.
+        project_id: Optional override for the default Project ID.
+
+    Returns:
+        LLM-friendly summary of the launch details.
+    """
+    auth_context = get_auth_context(project_id=project_id)
+    project = auth_context.project_id or settings.ALLURE_PROJECT_ID
+    if project is None:
+        raise ValueError("Project ID is required to retrieve launch details")
+
+    async with AllureClient(
+        base_url=settings.ALLURE_ENDPOINT,
+        token=auth_context.api_token,
+        project=project,
+    ) as client:
+        service = LaunchService(client=client)
+        launch = await service.get_launch(launch_id)
+
+    return _format_launch_detail(launch)
+
+
 def _format_launch_list(result: LaunchListResult) -> str:
     if not result.items:
         return "No launches found in this project."
@@ -110,3 +141,58 @@ def _format_launch_list(result: LaunchListResult) -> str:
         lines.append(f"\nUse page={result.page + 1} to see more results.")
 
     return "\n".join(lines)
+
+
+def _format_launch_detail(launch: object) -> str:
+    launch_id = getattr(launch, "id", None)
+    name = getattr(launch, "name", None) or "(unnamed)"
+    closed = getattr(launch, "closed", None)
+    status = "closed" if closed else "open"
+
+    lines = ["Launch details:"]
+    lines.append(f"- ID: {launch_id if launch_id is not None else 'unknown'}")
+    lines.append(f"- Name: {name}")
+    lines.append(f"- Status: {status}")
+
+    started_at = getattr(launch, "created_date", None) or getattr(launch, "createdDate", None)
+    ended_at = getattr(launch, "last_modified_date", None) or getattr(launch, "lastModifiedDate", None)
+
+    if started_at is not None:
+        lines.append(f"- Started: {started_at}")
+    if ended_at is not None:
+        lines.append(f"- Ended: {ended_at}")
+
+    field_labels = [
+        ("project_id", "Project ID"),
+        ("projectId", "Project ID"),
+        ("autoclose", "Autoclose"),
+        ("external", "External"),
+        ("known_defects_count", "Known defects"),
+        ("knownDefectsCount", "Known defects"),
+        ("new_defects_count", "New defects"),
+        ("newDefectsCount", "New defects"),
+    ]
+
+    seen_labels: set[str] = set()
+    for field_name, label in field_labels:
+        value = getattr(launch, field_name, None)
+        if value is None:
+            continue
+        if label in seen_labels:
+            continue
+        lines.append(f"- {label}: {value}")
+        seen_labels.add(label)
+
+    statistic = getattr(launch, "statistic", None)
+    if statistic:
+        summary_parts: list[str] = []
+        for item in statistic:
+            status_label = getattr(item, "status", None)
+            count = getattr(item, "count", None)
+            if status_label is None or count is None:
+                continue
+            summary_parts.append(f"{status_label!s}={count}")
+        if summary_parts:
+            lines.append(f"- Summary: {', '.join(summary_parts)}")
+
+    return "\n".join(lines)

src/tools/link_shared_step.py

@@ -1,6 +1,6 @@
 """Tool for linking Shared Steps to Test Cases."""
 
-from typing import Annotated, Any
+from typing import Annotated
 
 from pydantic import Field
 
@@ -9,25 +9,19 @@ from src.client.generated.models.shared_step_step_dto import SharedStepStepDto
 from src.services.test_case_service import TestCaseService
 
 
-def _format_steps(scenario: Any) -> str:
+def _format_steps(scenario: object) -> str:
     """Format steps for display."""
-    if not scenario or not scenario.steps:
+    steps = getattr(scenario, "steps", None)
+    if not isinstance(steps, list) or not steps:
         return "No steps."
 
     output = []
-    for i, step in enumerate(scenario.steps):
+    for i, step in enumerate(steps):
         # Handle Shared Step
         if step.actual_instance and isinstance(step.actual_instance, SharedStepStepDto):
-            # Ideally we would have the name, but DTO might only have ID if not enriched.
-            # SharedStepStepDto has 'sharedStepId'.
-            # Does it have 'name'? The scenarios steps in 'get_test_case_scenario'
-            # might not have name enriched unless we fetched it or denormalized it.
-            # The _denormalize_to_v2_from_dict doesn't currently inject name.
-            # For now, just show ID.
             output.append(f"{i + 1}. [Shared Step] ID: {step.actual_instance.shared_step_id}")
         else:
             # Inline step
-            # We assume it has some description or body
             body = "Step"
             if hasattr(step.actual_instance, "body"):
                 body = step.actual_instance.body or "Step"
@@ -48,8 +42,10 @@ async def link_shared_step(
         ),
     ] = None,
     project_id: Annotated[int | None, Field(description="Optional override for the default Project ID.")] = None,
+    confirm: Annotated[bool, Field(description="Must be set to True to proceed with linking. Safety measure.")] = False,
 ) -> str:
     """Link a shared step to a test case.
+    ⚠️ CAUTION: Destructive.
 
     Adds a reference to the shared step in the test case's step list.
     The shared step's actions will expand at execution time.
@@ -64,6 +60,8 @@ async def link_shared_step(
             - None = Append to end (default)
             - N = Insert after step N (so it becomes the (N+1)th step)
         project_id: Optional override for the default Project ID.
+        confirm: Must be set to True to proceed with linking.
+            This is a safety measure to prevent accidental linking.
 
     Returns:
         Confirmation with updated step list preview.
@@ -72,9 +70,17 @@ async def link_shared_step(
         link_shared_step(
             test_case_id=12345,
             shared_step_id=789,  # "Login as Admin"
-            position=0  # Insert at beginning
+            position=0,
+            confirm=True
         )
     """
+    if not confirm:
+        return (
+            "⚠️ Linking requires confirmation.\n\n"
+            "This will add a shared step to the test case scenario. "
+            f"Please call again with confirm=True to proceed with linking "
+            f"shared step {shared_step_id} to test case {test_case_id}."
+        )
 
     async with AllureClient.from_env(project=project_id) as client:
         service = TestCaseService(client=client)

src/tools/list_custom_field_values.py

@@ -0,0 +1,72 @@
+from typing import Annotated
+
+from pydantic import Field
+
+from src.client import AllureClient
+from src.services.custom_field_value_service import CustomFieldValueService
+
+
+async def list_custom_field_values(
+    custom_field_id: Annotated[
+        int | None, Field(description="Project-scoped custom field ID to list values for.")
+    ] = None,
+    custom_field_name: Annotated[
+        str | None,
+        Field(description="Custom field name to resolve when custom_field_id is not provided."),
+    ] = None,
+    query: Annotated[str | None, Field(description="Optional search query to filter values.")] = None,
+    var_global: Annotated[bool | None, Field(description="Optional filter for global values.")] = None,
+    test_case_search: Annotated[
+        str | None,
+        Field(description="Optional test case search filter to match values in test cases."),
+    ] = None,
+    page: Annotated[int | None, Field(description="Zero-based page index.")] = None,
+    size: Annotated[int | None, Field(description="Number of items per page.")] = None,
+    sort: Annotated[
+        list[str] | None,
+        Field(description="Optional sort criteria, e.g. ['name,asc', 'id,desc']"),
+    ] = None,
+    project_id: Annotated[int | None, Field(description="Optional override for the default Project ID.")] = None,
+) -> str:
+    """List available values for a custom field.
+
+    Args:
+        custom_field_id: Project-scoped custom field ID to list values for.
+        custom_field_name: Custom field name to resolve when custom_field_id is not provided.
+        query: Optional search query to filter values.
+        var_global: Optional filter for global values.
+        test_case_search: Optional test case search filter to match values in test cases.
+        page: Zero-based page index.
+        size: Number of items per page.
+        sort: Optional sort criteria, e.g. ["name,asc", "id,desc"].
+        project_id: Optional override for the default Project ID.
+    """
+    async with AllureClient.from_env(project=project_id) as client:
+        service = CustomFieldValueService(client=client)
+        result = await service.list_custom_field_values(
+            project_id=project_id,
+            custom_field_id=custom_field_id,
+            custom_field_name=custom_field_name,
+            query=query,
+            var_global=var_global,
+            test_case_search=test_case_search,
+            page=page,
+            size=size,
+            sort=sort,
+        )
+
+        values = result.content or []
+        if not values:
+            return "No custom field values found."
+
+        total = result.total_elements if result.total_elements is not None else len(values)
+        header = f"Found {total} custom field values:"
+        if result.number is not None and result.total_pages is not None:
+            header = f"Found {total} custom field values (page {result.number + 1}/{result.total_pages}):"
+
+        lines = [header]
+        for value in values:
+            count = value.test_cases_count if value.test_cases_count is not None else 0
+            lines.append(f"- ID: {value.id}, Name: {value.name}, Test cases: {count}")
+
+        return "\n".join(lines)

src/tools/list_integrations.py

@@ -0,0 +1,77 @@
+"""Tool for listing available integrations in Allure TestOps."""
+
+from typing import Annotated
+
+from pydantic import Field
+
+from src.client import AllureClient
+from src.services.integration_service import IntegrationService
+
+
+async def list_integrations(
+    project_id: Annotated[
+        int | None,
+        Field(
+            description=(
+                "Optional override for the default Project ID. "
+                "Note: Integrations are configured at the instance level, not per-project, "
+                "but this parameter is accepted for API consistency."
+            )
+        ),
+    ] = None,
+) -> str:
+    """List available integrations (issue trackers) in Allure TestOps.
+
+    Use this tool to discover which integrations (Jira, GitHub, etc.) are
+    configured and available for linking issues to test cases.
+
+    Args:
+        project_id: Optional override for the default Project ID.
+            Note: Integrations are configured at the instance level, not per-project,
+            but this parameter is accepted for API consistency.
+
+    Returns:
+        A formatted list of available integrations with their IDs and names.
+        If no integrations are configured, returns an informative message.
+
+    Examples:
+        >>> list_integrations()
+        "📋 Available Integrations (3 found):
+         • Github Integration (ID: 1) [github]
+         • Noxtua Jira Integration (ID: 2) [jira]
+         • TestOps TMS (ID: 3) [tms]
+
+         Hint: Use 'integration_id' or 'integration_name' when creating/updating
+         test cases with issues to specify which integration to use."
+    """
+    async with AllureClient.from_env(project=project_id) as client:
+        service = IntegrationService(client)
+        integrations = await service.list_integrations()
+
+        if not integrations:
+            return (
+                "📋 No integrations configured.\n\n"
+                "Integrations connect Allure TestOps to external issue trackers "
+                "(Jira, GitHub, etc.). Contact your Allure admin to configure integrations."
+            )
+
+        # Format output
+        lines: list[str] = [f"📋 **Available Integrations** ({len(integrations)} found):\n"]
+
+        for integration in integrations:
+            name = integration.name or "(unnamed)"
+            int_id = integration.id or "N/A"
+            info_type = ""
+            if integration.info and hasattr(integration.info, "type") and integration.info.type:
+                # Handle enum or string; since IntegrationTypeDto is (str, Enum), .value works or its just the str
+                info_type = getattr(integration.info.type, "value", str(integration.info.type))
+                info_type = f" [{info_type.lower()}]"
+            lines.append(f"• **{name}** (ID: {int_id}){info_type}")
+
+        lines.append("")
+        lines.append(
+            "**Hint:** Use `integration_id` or `integration_name` when creating/updating "
+            "test cases with issues to specify which integration to use."
+        )
+
+        return "\n".join(lines)