Criando um GPT que insere tarefas dentro do Jira

Como Criar um GPT que Automatiza a Criação de Tarefas no Jira usando Cloud Functions em Python

No desenvolvimento ágil, tarefas e histórias de usuário são fundamentais para a organização de demandas. Usar o GPT para criação automática de tarefas no Jira facilita muito o processo, economizando tempo ao estruturar e documentar histórias com critérios bem definidos. Neste artigo, explico como configurar um GPT que cria tarefas automaticamente no Jira usando uma Cloud Function em Python e a API do Jira.

Passo 1: Estrutura do Código em Python para Cloud Function

Para automatizar a criação de tarefas no Jira, vamos criar uma Cloud Function em Python. Esta função será configurada como uma action do GPT e responderá ao prompt do usuário, executando a criação da tarefa no Jira.

1.1 Dependências Necessárias

Para este projeto, utilize a biblioteca oficial do Jira para Python, que simplifica a autenticação e manipulação das APIs:

pip install jira

1.2 Configurando a Conexão com o Jira

O código a seguir realiza a autenticação e a criação da tarefa no Jira:

from jira import JIRA
import functions_framework  # framework para Google Cloud Functions

@functions_framework.http
def create_jira_issue(request):
    # Configurações do Jira
    jira_options = {'server': 'https://seu_dominio.atlassian.net'}
    jira = JIRA(options=jira_options, basic_auth=('email@email.com.br', 'TOKEN_JIRA'))

    # Recebendo dados JSON da requisição
    request_json = request.get_json(silent=True)
    if not request_json:
        return {"status": "Request body is missing"}, 400

    project_key = request_json.get("key")
    summary = request_json.get("summary")
    description = request_json.get("description")

    # Definindo os detalhes da user story
    issue_dict = {
        'project': {'key': project_key},
        'summary': summary,
        'description': description,
        'issuetype': {'name': 'Story'},
    }

    # Criando a tarefa no Jira
    try:
        new_issue = jira.create_issue(fields=issue_dict)
        return {
            "issueId": new_issue.key,
            "status": "Issue created successfully"
        }, 200
    except Exception as e:
        return {"status": f"Error: {str(e)}"}, 500

Este código:

  1. Autentica no Jira usando um domínio, email e token de API.
  2. Recebe dados JSON da solicitação HTTP com os detalhes da tarefa.
  3. Cria a tarefa no Jira usando jira.create_issue().
  4. Retorna uma resposta com o ID da tarefa criada, caso seja bem-sucedida.

Passo 2: Criando e Configurando a Action no GPT

Para que o GPT utilize a Cloud Function, configuraremos uma action baseada no OpenAPI Schema. Esta action receberá o project_key, summary e description e retornará o issueId da tarefa criada.

2.1 Estrutura do OpenAPI Schema

O schema OpenAPI especifica os detalhes de nossa action, facilitando a integração com o GPT. Abaixo está o schema completo:

{
  "openapi": "3.1.0",
  "info": {
    "title": "jira issue",
    "description": "Create jira issue based on inputs",
    "version": "v1.0.0"
  },
  "servers": [
    {
      "url": "https://us-central1-jira-gpt.cloudfunctions.net"
    }
  ],
  "paths": {
    "/create-jira": {
      "post": {
        "description": "Create Jira Issue",
        "operationId": "CreateJiraIssue",
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "key": {
                    "type": "string",
                    "description": "Key for the project in Jira",
                    "example": "PROJ1"
                  },
                  "summary": {
                    "type": "string",
                    "description": "Summary of the issue",
                    "example": "Bug fix required in authentication module"
                  },
                  "description": {
                    "type": "string",
                    "description": "Detailed description of the issue",
                    "example": "The authentication module is throwing a 500 error on login."
                  }
                },
                "required": ["key", "summary", "description"]
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful issue creation",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "issueId": {
                      "type": "string",
                      "description": "ID of the created issue",
                      "example": "10001"
                    },
                    "status": {
                      "type": "string",
                      "description": "Status of the issue creation",
                      "example": "Issue created successfully"
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

2.2 Configurando o Prompt do GPT

O prompt inicial do GPT será utilizado para coletar as informações e apresentar ao usuário o formato necessário de criação da história de usuário, garantindo clareza e completude nos dados. Aqui está o exemplo do prompt que o GPT deve seguir:

Objetivo:
Ajudar a criar uma história de usuário eficiente com critérios de aceitação claros.

1. Início da interação:
- Cumprimente o usuário de forma cordial.
- Informe que você vai ajudar a criar uma história de usuário.

2. Identificação:
- Pergunte quem está executando a ação.

3. Ação:
- Pergunte qual ação o usuário deseja realizar.

4. Objetivo/Motivação:
- Pergunte por que o usuário quer realizar essa ação e qual o objetivo final.

5. Critérios de Aceitação:
- Sugira critérios de aceitação com base nas respostas.
- Pergunte se o usuário gostaria de acrescentar outros critérios de aceite.

6. Validação:
- Peça ao usuário que valide o conteúdo.

7. Formato Final:
```
Como [pessoa] [executando/fazendo] a [ação]
Eu quero [o que deve acontecer]
Para [objetivo/finalidade]

Critérios de aceitação:
- [Critério de aceitação 1]
- [Critério de aceitação 2]
```

8. Apresente a história no formato padrão e pergunte se deseja criar no Jira.
 - Se o usuário confirmar, pergunte qual a KEY do projeto jira
 - Execute a action CreateJiraIssue com os parametros abaixo:
  - key: '[valor da KEY do projeto que o usuário informou acima]'
  - summary: '[gere com base na história gerada]'
  - description: '[todo o conteúdo da história gerada com os critérios de aceite]'

Exemplo:
```
Como usuário administrador logado na plataforma, cadastrando um novo usuário
Quero que a tela de cadastro apresente uma lista de perfis 
Para que eu possa cadastrar diferentes perfis de usuário

Critérios de aceitação:
- A lista deve apresentar os perfis Administrador, Usuário Simples e Usuário Editor
- Apenas usuário Administrador pode cadastrar um novo perfil Administrador
- Usuário Simples não pode conseguir cadastrar nenhum usuário
```

Passo 3: Implantação e Testes

  1. Implantação da Cloud Function: No console do Google Cloud, crie uma nova Cloud Function, selecione Python e cole o código Python que criamos. Configure a função como pública ou protegida, conforme necessário.
  2. Configuração da Action no GPT: Com o OpenAPI Schema, configure a action no GPT e defina operationId como "CreateJiraIssue" (ou só copia o código que deixei acima rs).
  3. Testes Finais: Teste o GPT para garantir que as interações e a criação de tarefas estejam funcionando corretamente (tente usar o app do Chat GPT no modo conversa, é bem legal, também funciona você enviando uma documentação do projeto e pedindo que o GPT crie as tarefas de acordo com a documentação).