titan-cli 0.4.2__tar.gz → 0.4.4__tar.gz

{titan_cli-0.4.2 → titan_cli-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: titan-cli
-Version: 0.4.2
+Version: 0.4.4
 Summary: Modular development tools orchestrator - Streamline your workflows with AI integration and intuitive terminal UI
 License: MIT
 License-File: LICENSE

{titan_cli-0.4.2 → titan_cli-0.4.4}/plugins/titan-plugin-git/titan_plugin_git/steps/create_worktree_step.py

@@ -30,6 +30,10 @@ def create_worktree(ctx: WorkflowContext) -> WorkflowResult:
         worktree_path: Path to the created worktree
         base_branch: Base branch name (e.g., "develop" or "main")
 
+    Returns:
+        Success: If the worktree is created successfully.
+        Error: If the Git client is unavailable or worktree creation fails.
+
     Example:
         ```yaml
         - name: "Create Worktree"

{titan_cli-0.4.2 → titan_cli-0.4.4}/plugins/titan-plugin-git/titan_plugin_git/steps/remove_worktree_step.py

@@ -21,6 +21,10 @@ def remove_worktree(ctx: WorkflowContext) -> WorkflowResult:
         path: Path to the worktree to remove (required, or uses worktree_path from context)
         force: Force removal even if worktree has uncommitted changes (default: false)
 
+    Returns:
+        Success: If the worktree is removed successfully or is already gone.
+        Error: If cleanup fails.
+
     Example:
         ```yaml
         - name: "Cleanup Worktree"

{titan_cli-0.4.2 → titan_cli-0.4.4}/plugins/titan-plugin-git/titan_plugin_git/steps/worktree_command_step.py

@@ -18,6 +18,10 @@ def worktree_commit(ctx: WorkflowContext) -> WorkflowResult:
         message: Commit message (required)
         add_all: Stage all changes before committing (default: true)
 
+    Returns:
+        Success: If the commit is created in the worktree.
+        Error: If required context is missing or the git command fails.
+
     Example:
         ```yaml
         - name: "Commit in Worktree"
@@ -105,6 +109,10 @@ def worktree_push(ctx: WorkflowContext) -> WorkflowResult:
         branch: Branch to push (optional, pushes current branch if not specified)
         set_upstream: Set upstream tracking (default: true)
 
+    Returns:
+        Success: If the branch is pushed from the worktree.
+        Error: If required context is missing or the git command fails.
+
     Example:
         ```yaml
         - name: "Push from Worktree"

{titan_cli-0.4.2 → titan_cli-0.4.4}/plugins/titan-plugin-github/titan_plugin_github/plugin.py

@@ -136,6 +136,11 @@ class GitHubPlugin(TitanPlugin):
         from .steps.ai_pr_step import ai_suggest_pr_description_step
         from .steps.issue_steps import ai_suggest_issue_title_and_body_step, create_issue_steps
         from .steps.preview_step import preview_and_confirm_issue_step
+        from .steps.pull_request_steps import (
+            get_pull_request_step,
+            merge_pull_request_step,
+            verify_pull_request_state_step,
+        )
         from .steps.pr_review_steps import (
             select_pr_for_review_step,
             fetch_pending_comments_step,
@@ -184,6 +189,9 @@ class GitHubPlugin(TitanPlugin):
             "ai_suggest_issue_title_and_body": ai_suggest_issue_title_and_body_step,
             "create_issue": create_issue_steps,
             "preview_and_confirm_issue": preview_and_confirm_issue_step,
+            "get_pull_request": get_pull_request_step,
+            "merge_pull_request": merge_pull_request_step,
+            "verify_pull_request_state": verify_pull_request_state_step,
             "select_pr_for_review": select_pr_for_review_step,
             "fetch_pending_comments": fetch_pending_comments_step,
             "check_clean_state": check_clean_state_step,

{titan_cli-0.4.2 → titan_cli-0.4.4}/plugins/titan-plugin-github/titan_plugin_github/steps/github_prompt_steps.py

@@ -134,6 +134,16 @@ def prompt_for_issue_body_step(ctx: WorkflowContext) -> WorkflowResult:
 def prompt_for_self_assign_step(ctx: WorkflowContext) -> WorkflowResult:
     """
     Asks the user if they want to assign the issue to themselves.
+
+    Requires:
+        ctx.github: An initialized GitHubClient.
+
+    Outputs (saved to ctx.data):
+        assignees (list[str]): Updated assignees list when the user chooses self-assignment.
+
+    Returns:
+        Success: If the assignment preference is captured successfully.
+        Error: If the GitHub client is unavailable or the prompt fails.
     """
     if not ctx.textual:
         return Error("Textual UI context is not available for this step.")
@@ -176,6 +186,17 @@ def prompt_for_self_assign_step(ctx: WorkflowContext) -> WorkflowResult:
 def prompt_for_labels_step(ctx: WorkflowContext) -> WorkflowResult:
     """
     Prompts the user to select labels for the issue.
+
+    Requires:
+        ctx.github: An initialized GitHubClient.
+
+    Outputs (saved to ctx.data):
+        labels (list[str]): Labels selected by the user.
+
+    Returns:
+        Success: If label selection completes successfully.
+        Skip: If the repository has no labels.
+        Error: If the GitHub client is unavailable or the prompt fails.
     """
     if not ctx.textual:
         return Error("Textual UI context is not available for this step.")

{titan_cli-0.4.2 → titan_cli-0.4.4}/plugins/titan-plugin-github/titan_plugin_github/steps/issue_steps.py

@@ -10,6 +10,20 @@ def ai_suggest_issue_title_and_body_step(ctx: WorkflowContext) -> WorkflowResult
     """
     Use AI to suggest a title and description for a GitHub issue.
     Auto-categorizes and selects the appropriate template.
+
+    Inputs (from ctx.data):
+        issue_body (str): Raw issue request entered by the user.
+
+    Outputs (saved to ctx.data):
+        issue_title (str): AI-generated or user-edited title.
+        issue_body (str): AI-generated or user-edited body.
+        issue_category (str): Detected issue category.
+        labels (list[str]): Suggested labels for the issue.
+
+    Returns:
+        Success: If issue content is generated and accepted.
+        Skip: If AI is unavailable or the user rejects the generated issue.
+        Error: If required context is missing or generation fails.
     """
     if not ctx.textual:
         return Error("Textual UI context is not available for this step.")
@@ -98,6 +112,22 @@ def ai_suggest_issue_title_and_body_step(ctx: WorkflowContext) -> WorkflowResult
 def create_issue_steps(ctx: WorkflowContext) -> WorkflowResult:
     """
     Create a new GitHub issue.
+
+    Requires:
+        ctx.github: An initialized GitHubClient.
+
+    Inputs (from ctx.data):
+        issue_title (str): Issue title.
+        issue_body (str): Issue body.
+        assignees (list, optional): Usernames to assign.
+        labels (list, optional): Labels to apply.
+
+    Outputs (saved to ctx.data):
+        issue (GitHubIssue): The created issue object.
+
+    Returns:
+        Success: If the issue is created successfully.
+        Error: If required context is missing or the GitHub call fails.
     """
     if not ctx.textual:
         return Error("Textual UI context is not available for this step.")

{titan_cli-0.4.2 → titan_cli-0.4.4}/plugins/titan-plugin-github/titan_plugin_github/steps/preview_step.py

@@ -4,6 +4,14 @@ from titan_cli.engine.results import WorkflowResult, Success, Error
 def preview_and_confirm_issue_step(ctx: WorkflowContext) -> WorkflowResult:
     """
     Show a preview of the AI-generated issue and ask for confirmation.
+
+    Inputs (from ctx.data):
+        issue_title (str): Generated issue title.
+        issue_body (str): Generated issue body.
+
+    Returns:
+        Success: If the user confirms the issue preview.
+        Error: If required context is missing, the user rejects, or the prompt is cancelled.
     """
     if not ctx.textual:
         return Error("Textual UI context is not available for this step.")

titan_cli-0.4.4/plugins/titan-plugin-github/titan_plugin_github/steps/pull_request_steps.py

@@ -0,0 +1,199 @@
+"""Reusable workflow steps for GitHub pull request operations."""
+
+from titan_cli.core.result import ClientError, ClientSuccess
+from titan_cli.engine import Error, Success, WorkflowContext, WorkflowResult
+
+from ..messages import msg
+
+
+def get_pull_request_step(ctx: WorkflowContext) -> WorkflowResult:
+    """
+    Fetch a pull request and store it in workflow context.
+
+    Requires:
+        ctx.github: An initialized GitHubClient.
+
+    Inputs (from ctx.data):
+        pr_number (int): Pull request number to fetch.
+
+    Outputs (saved to ctx.data):
+        pr_info: The fetched pull request object.
+
+    Returns:
+        Success: If the pull request is fetched successfully.
+        Error: If required context is missing or the GitHub call fails.
+    """
+    if not ctx.textual:
+        return Error("Textual UI context is not available for this step.")
+
+    ctx.textual.begin_step("Fetch Pull Request")
+
+    if not ctx.github:
+        ctx.textual.error_text("GitHub client not available")
+        ctx.textual.end_step("error")
+        return Error("GitHub client not available")
+
+    pr_number = ctx.get("pr_number")
+    if not pr_number:
+        ctx.textual.error_text("No PR number in context")
+        ctx.textual.end_step("error")
+        return Error("No PR number in context")
+
+    with ctx.textual.loading(f"Fetching PR #{pr_number}..."):
+        result = ctx.github.get_pull_request(int(pr_number))
+
+    match result:
+        case ClientSuccess(data=pr_info):
+            ctx.textual.success_text(f"PR #{pr_info.number}: {pr_info.title}")
+            ctx.textual.end_step("success")
+            return Success(
+                f"Fetched PR #{pr_info.number}",
+                metadata={"pr_info": pr_info},
+            )
+        case ClientError(error_message=err):
+            ctx.textual.error_text(f"Failed to fetch PR: {err}")
+            ctx.textual.end_step("error")
+            return Error(f"Failed to fetch PR: {err}")
+
+
+def merge_pull_request_step(ctx: WorkflowContext) -> WorkflowResult:
+    """
+    Merge a pull request using the configured GitHub client.
+
+    Requires:
+        ctx.github: An initialized GitHubClient.
+
+    Inputs (from ctx.data):
+        pr_number (int): Pull request number to merge.
+        merge_method (str, optional): Merge strategy.
+        commit_title (str, optional): Override commit title.
+        commit_message (str, optional): Override commit message.
+
+    Outputs (saved to ctx.data):
+        merge_result: The GitHub merge result object.
+
+    Returns:
+        Success: If the pull request is merged successfully.
+        Error: If required context is missing or the GitHub call fails.
+    """
+    if not ctx.textual:
+        return Error("Textual UI context is not available for this step.")
+
+    ctx.textual.begin_step("Merge Pull Request")
+
+    if not ctx.github:
+        ctx.textual.error_text("GitHub client not available")
+        ctx.textual.end_step("error")
+        return Error("GitHub client not available")
+
+    pr_number = ctx.get("pr_number")
+    if not pr_number:
+        ctx.textual.error_text("No PR number in context")
+        ctx.textual.end_step("error")
+        return Error("No PR number in context")
+
+    merge_method = ctx.get("merge_method", "squash")
+    commit_title = ctx.get("commit_title")
+    commit_message = ctx.get("commit_message")
+
+    with ctx.textual.loading(f"Merging PR #{pr_number} with {merge_method}..."):
+        result = ctx.github.merge_pr(
+            int(pr_number),
+            merge_method=merge_method,
+            commit_title=commit_title,
+            commit_message=commit_message,
+        )
+
+    match result:
+        case ClientSuccess(data=merge_result):
+            if not merge_result.merged:
+                ctx.textual.error_text(f"Failed to merge PR #{pr_number}: {merge_result.message}")
+                ctx.textual.end_step("error")
+                return Error(f"Failed to merge PR #{pr_number}: {merge_result.message}")
+
+            ctx.textual.success_text(msg.GitHub.PR_MERGED.format(number=pr_number))
+            ctx.textual.end_step("success")
+            return Success(
+                f"Merged PR #{pr_number}",
+                metadata={"merge_result": merge_result},
+            )
+        case ClientError(error_message=err):
+            ctx.textual.error_text(f"Failed to merge PR: {err}")
+            ctx.textual.end_step("error")
+            return Error(f"Failed to merge PR: {err}")
+
+
+def verify_pull_request_state_step(ctx: WorkflowContext) -> WorkflowResult:
+    """
+    Verify a pull request is currently in the expected state.
+
+    Requires:
+        ctx.github: An initialized GitHubClient.
+
+    Inputs (from ctx.data):
+        pr_number (int): Pull request number to inspect.
+        expected_state (str): Expected pull request state.
+
+    Outputs (saved to ctx.data):
+        verified_pr_info: The pull request object when verification succeeds.
+
+    Returns:
+        Success: If the pull request is in the expected state.
+        Error: If required context is missing, verification fails, or the GitHub call fails.
+    """
+    if not ctx.textual:
+        return Error("Textual UI context is not available for this step.")
+
+    ctx.textual.begin_step("Verify Pull Request State")
+
+    if not ctx.github:
+        ctx.textual.error_text("GitHub client not available")
+        ctx.textual.end_step("error")
+        return Error("GitHub client not available")
+
+    pr_number = ctx.get("pr_number")
+    if not pr_number:
+        ctx.textual.error_text("No PR number in context")
+        ctx.textual.end_step("error")
+        return Error("No PR number in context")
+
+    expected_state = ctx.get("expected_state")
+    if not expected_state:
+        ctx.textual.error_text("No expected PR state in context")
+        ctx.textual.end_step("error")
+        return Error("No expected PR state in context")
+
+    expected_state = str(expected_state).upper()
+
+    with ctx.textual.loading(f"Verifying PR #{pr_number} state..."):
+        result = ctx.github.get_pull_request(int(pr_number))
+
+    match result:
+        case ClientSuccess(data=pr_info):
+            actual_state = str(pr_info.state).upper()
+            if actual_state != expected_state:
+                ctx.textual.error_text(
+                    f"PR #{pr_number} is {actual_state}, expected {expected_state}"
+                )
+                ctx.textual.end_step("error")
+                return Error(
+                    f"PR #{pr_number} state mismatch: expected {expected_state}, got {actual_state}"
+                )
+
+            ctx.textual.success_text(f"PR #{pr_number} is {actual_state}")
+            ctx.textual.end_step("success")
+            return Success(
+                f"Verified PR #{pr_number} is {actual_state}",
+                metadata={"verified_pr_info": pr_info},
+            )
+        case ClientError(error_message=err):
+            ctx.textual.error_text(f"Failed to verify PR state: {err}")
+            ctx.textual.end_step("error")
+            return Error(f"Failed to verify PR state: {err}")
+
+
+__all__ = [
+    "get_pull_request_step",
+    "merge_pull_request_step",
+    "verify_pull_request_state_step",
+]

{titan_cli-0.4.2 → titan_cli-0.4.4}/plugins/titan-plugin-jira/titan_plugin_jira/clients/jira_client.py

@@ -360,6 +360,65 @@ class JiraClient:
 
         return self._metadata_service.list_project_versions(key)
 
+    def create_version(
+        self,
+        name: str,
+        project_key: Optional[str] = None,
+        description: Optional[str] = None,
+        release_date: Optional[str] = None,
+    ) -> ClientResult[UIJiraVersion]:
+        """Create a version in the provided or default Jira project."""
+        key = project_key or self.project_key
+        if not key:
+            return ClientError(
+                error_message="Project key not provided",
+                error_code="MISSING_PROJECT_KEY"
+            )
+
+        return self._metadata_service.create_version(
+            project_key=key,
+            name=name,
+            description=description,
+            release_date=release_date,
+        )
+
+    def ensure_version_exists(
+        self,
+        name: str,
+        project_key: Optional[str] = None,
+        description: Optional[str] = None,
+        release_date: Optional[str] = None,
+    ) -> ClientResult[UIJiraVersion]:
+        """Return an existing version by name or create it if missing."""
+        key = project_key or self.project_key
+        if not key:
+            return ClientError(
+                error_message="Project key not provided",
+                error_code="MISSING_PROJECT_KEY"
+            )
+
+        return self._metadata_service.ensure_version_exists(
+            project_key=key,
+            name=name,
+            description=description,
+            release_date=release_date,
+        )
+
+    def assign_fix_version(
+        self,
+        issue_key: str,
+        version_id: Optional[str] = None,
+        version_name: Optional[str] = None,
+        project_key: Optional[str] = None,
+    ) -> ClientResult[None]:
+        """Assign a fixVersion to an issue by version ID or version name."""
+        return self._issue_service.assign_fix_version_reference(
+            issue_key=issue_key,
+            project_key=project_key or self.project_key,
+            version_id=version_id,
+            version_name=version_name,
+        )
+
     def get_priorities(self) -> ClientResult[List[UIPriority]]:
         """
         Get all available priorities in Jira.

{titan_cli-0.4.2 → titan_cli-0.4.4}/plugins/titan-plugin-jira/titan_plugin_jira/clients/services/issue_service.py

@@ -362,6 +362,93 @@ class IssueService:
                 error_code="CREATE_SUBTASK_ERROR"
             )
 
+    @log_client_operation()
+    def assign_fix_version(
+        self,
+        issue_key: str,
+        version_id: str,
+    ) -> ClientResult[None]:
+        """Assign a fixVersion to an issue using a Jira version ID."""
+        try:
+            payload = {
+                "update": {
+                    "fixVersions": [
+                        {
+                            "add": {"id": version_id}
+                        }
+                    ]
+                }
+            }
+
+            self.network.make_request("PUT", f"issue/{issue_key}", json=payload)
+
+            return ClientSuccess(
+                data=None,
+                message=f"Assigned fixVersion {version_id} to {issue_key}",
+            )
+
+        except JiraAPIError as e:
+            return ClientError(
+                error_message=f"Failed to assign fixVersion {version_id} to {issue_key}: {e.message}",
+                error_code="ASSIGN_FIX_VERSION_ERROR",
+            )
+
+    @log_client_operation()
+    def assign_fix_version_by_name(
+        self,
+        issue_key: str,
+        project_key: str,
+        version_name: str,
+    ) -> ClientResult[None]:
+        """Assign a fixVersion to an issue by resolving a project version name."""
+        if not self.metadata_service:
+            return ClientError(
+                error_message="MetadataService not available",
+                error_code="SERVICE_NOT_AVAILABLE"
+            )
+
+        versions_result = self.metadata_service.list_project_versions(project_key)
+        match versions_result:
+            case ClientSuccess(data=versions):
+                matching_version = next(
+                    (version for version in versions if version.name == version_name),
+                    None,
+                )
+                if not matching_version:
+                    return ClientError(
+                        error_message=f"Version '{version_name}' not found in project {project_key}",
+                        error_code="VERSION_NOT_FOUND"
+                    )
+                return self.assign_fix_version(issue_key, matching_version.id)
+            case ClientError() as error:
+                return error
+
+    @log_client_operation()
+    def assign_fix_version_reference(
+        self,
+        issue_key: str,
+        project_key: str | None = None,
+        version_id: str | None = None,
+        version_name: str | None = None,
+    ) -> ClientResult[None]:
+        """Assign a fixVersion to an issue by version ID or version name."""
+        if version_id:
+            return self.assign_fix_version(issue_key, version_id)
+
+        if not version_name:
+            return ClientError(
+                error_message="Either version_id or version_name is required",
+                error_code="MISSING_VERSION_REFERENCE"
+            )
+
+        if not project_key:
+            return ClientError(
+                error_message="Project key not provided",
+                error_code="MISSING_PROJECT_KEY"
+            )
+
+        return self.assign_fix_version_by_name(issue_key, project_key, version_name)
+
     def _convert_text_to_adf(self, text: str) -> dict:
         """
         Convert plain text to Atlassian Document Format (ADF).

{titan_cli-0.4.2 → titan_cli-0.4.4}/plugins/titan-plugin-jira/titan_plugin_jira/clients/services/metadata_service.py

@@ -224,6 +224,76 @@ class MetadataService:
                 error_code="LIST_VERSIONS_ERROR",
             )
 
+    @log_client_operation()
+    def create_version(
+        self,
+        project_key: str,
+        name: str,
+        description: str | None = None,
+        release_date: str | None = None,
+    ) -> ClientResult[UIJiraVersion]:
+        """Create a Jira version for a project."""
+        try:
+            payload = {
+                "project": project_key,
+                "name": name,
+            }
+
+            if description:
+                payload["description"] = description
+            if release_date:
+                payload["releaseDate"] = release_date
+
+            data = self.network.make_request("POST", "version", json=payload)
+
+            network_version = NetworkJiraVersion(
+                id=data.get("id", ""),
+                name=data.get("name", name),
+                description=data.get("description"),
+                released=data.get("released", False),
+                releaseDate=data.get("releaseDate"),
+            )
+
+            return ClientSuccess(
+                data=from_network_version(network_version),
+                message=f"Version {name} created",
+            )
+
+        except JiraAPIError as e:
+            return ClientError(
+                error_message=f"Failed to create version {name} in {project_key}: {e.message}",
+                error_code="CREATE_VERSION_ERROR",
+            )
+
+    @log_client_operation()
+    def ensure_version_exists(
+        self,
+        project_key: str,
+        name: str,
+        description: str | None = None,
+        release_date: str | None = None,
+    ) -> ClientResult[UIJiraVersion]:
+        """Return an existing version by name or create it if missing."""
+        versions_result = self.list_project_versions(project_key)
+
+        match versions_result:
+            case ClientSuccess(data=versions):
+                existing_version = next((version for version in versions if version.name == name), None)
+                if existing_version:
+                    return ClientSuccess(
+                        data=existing_version,
+                        message=f"Version {name} already exists",
+                    )
+            case ClientError() as error:
+                return error
+
+        return self.create_version(
+            project_key=project_key,
+            name=name,
+            description=description,
+            release_date=release_date,
+        )
+
     def get_priorities(self) -> ClientResult[List[UIPriority]]:
         """
         Get all available priorities in Jira.

{titan_cli-0.4.2 → titan_cli-0.4.4}/plugins/titan-plugin-jira/titan_plugin_jira/messages.py

@@ -48,6 +48,29 @@ class Messages:
             GET_FAILED: str = "Failed to get JIRA issue: {e}"
             ISSUE_NOT_FOUND: str = "JIRA issue not found: {issue_key}"
 
+        class Versions:
+            """Version management step messages"""
+            LIST_PROJECT_REQUIRED: str = "project_key is required. Provide it in workflow params or configure default_project in JIRA plugin."
+            VERSION_NAME_REQUIRED: str = "version_name is required"
+            CREATE_SUCCESS: str = "Created JIRA version: {version_name}"
+            CREATE_FAILED: str = "Failed to create JIRA version: {e}"
+            ENSURE_SUCCESS: str = "Version available: {version_name}"
+            ASSIGN_SUCCESS: str = "Assigned fix version '{version_name}' to {issue_key}"
+            ASSIGN_FAILED: str = "Failed to assign fix version: {e}"
+            VERIFY_SUCCESS: str = "Issue {issue_key} has fix version '{version_name}'"
+            VERIFY_FAILED: str = "Issue {issue_key} does not have fix version '{version_name}'"
+
+        class Transitions:
+            """Transition workflow step messages"""
+            ISSUE_KEY_REQUIRED: str = "JIRA issue key is required"
+            TARGET_STATUS_REQUIRED: str = "target_status is required"
+            GET_SUCCESS: str = "Retrieved {count} transition(s) for {issue_key}"
+            GET_FAILED: str = "Failed to get transitions: {e}"
+            TRANSITION_SUCCESS: str = "Updated JIRA issue {issue_key} to {status}"
+            TRANSITION_FAILED: str = "Failed to transition JIRA issue: {e}"
+            VERIFY_SUCCESS: str = "Issue {issue_key} is in status '{status}'"
+            VERIFY_FAILED: str = "Issue {issue_key} is '{actual_status}', expected '{expected_status}'"
+
         class CreateIssue:
             """Create issue step messages"""
             CREATING_ISSUE: str = "Creating JIRA issue: {summary}"

{titan_cli-0.4.2 → titan_cli-0.4.4}/plugins/titan-plugin-jira/titan_plugin_jira/operations/__init__.py

@@ -29,6 +29,13 @@ from .issue_operations import (
     transition_issue_to_ready_for_dev,
 )
 
+from .issue_management_operations import (
+    find_transition_by_target_status,
+    find_transition_by_name_contains,
+    find_version_by_name,
+    issue_has_fix_version,
+)
+
 __all__ = [
     # JQL operations
     "substitute_jql_variables",
@@ -44,4 +51,9 @@ __all__ = [
     # Issue operations
     "find_ready_to_dev_transition",
     "transition_issue_to_ready_for_dev",
+    # Workflow operations
+    "find_transition_by_target_status",
+    "find_transition_by_name_contains",
+    "find_version_by_name",
+    "issue_has_fix_version",
 ]