home / skills / 89jobrien / steve / jira

jira skill

/steve/skills/jira

This skill helps you manage Jira Cloud issues, search with JQL, and automate creating, updating, commenting, and transitions via REST API.

npx playbooks add skill 89jobrien/steve --skill jira

Review the files below or copy the command above to add this skill to your agents.

Files (5)
SKILL.md
4.5 KB
---
name: jira
description: Jira Cloud integration for issue management and search. This skill should
  be used when working with Jira tickets, searching issues with JQL, creating or updating
  issues, adding comments, or transitioning issue status. Covers REST API v3 and Jira
  Query Language.
author: Joseph OBrien
status: unpublished
updated: '2025-12-23'
version: 1.0.1
tag: skill
type: skill
---

# Jira Integration Skill

This skill enables direct interaction with Jira Cloud via REST API v3 and JQL queries.

## Prerequisites

Set these environment variables (or in `.env` file):

```bash
JIRA_DOMAIN=company.atlassian.net
[email protected]
JIRA_API_TOKEN=your-api-token
```

Generate API tokens at: <https://id.atlassian.com/manage-profile/security/api-tokens>

## Core Workflows

### 1. Get Issue Details

To retrieve issue information:

```bash
python scripts/jira_api.py GET /issue/PROJ-123
```

With specific fields:

```bash
python scripts/jira_api.py GET "/issue/PROJ-123?fields=summary,status,assignee"
```

### 2. Search with JQL

To search issues using JQL:

```bash
python scripts/jira_api.py GET /search --query "jql=project=AOP AND status='In Progress'&maxResults=20"
```

Common JQL patterns - see `references/jql-reference.md`:

- My open issues: `assignee = currentUser() AND resolution = Unresolved`
- Recent updates: `updated >= -1d ORDER BY updated DESC`
- Sprint work: `sprint in openSprints() AND assignee = currentUser()`

### 3. Create Issue

To create a new issue, use ADF format for description (see `references/adf-format.md`):

```bash
python scripts/jira_api.py POST /issue --data '{
  "fields": {
    "project": { "key": "PROJ" },
    "issuetype": { "name": "Task" },
    "summary": "Issue title",
    "description": {
      "type": "doc",
      "version": 1,
      "content": [
        {
          "type": "paragraph",
          "content": [{ "type": "text", "text": "Description here" }]
        }
      ]
    }
  }
}'
```

### 4. Update Issue

To update fields on an existing issue:

```bash
python scripts/jira_api.py PUT /issue/PROJ-123 --data '{
  "fields": {
    "summary": "Updated title",
    "labels": ["label1", "label2"]
  }
}'
```

### 5. Add Comment

To add a comment (requires ADF format):

```bash
python scripts/jira_api.py POST /issue/PROJ-123/comment --data '{
  "body": {
    "type": "doc",
    "version": 1,
    "content": [
      {
        "type": "paragraph",
        "content": [{ "type": "text", "text": "Comment text here" }]
      }
    ]
  }
}'
```

### 6. Transition Issue Status

First, get available transitions:

```bash
python scripts/jira_api.py GET /issue/PROJ-123/transitions
```

Then transition to new status:

```bash
python scripts/jira_api.py POST /issue/PROJ-123/transitions --data '{
  "transition": { "id": "21" }
}'
```

### 7. Assign Issue

To assign an issue:

```bash
# Get user account ID first
python scripts/jira_api.py GET "/user/search?query=username"

# Then assign
python scripts/jira_api.py PUT /issue/PROJ-123/assignee --data '{
  "accountId": "user-account-id"
}'
```

To unassign:

```bash
python scripts/jira_api.py PUT /issue/PROJ-123/assignee --data '{"accountId": null}'
```

## Direct curl Usage

For quick operations without the helper script:

```bash
JIRA_DOMAIN="company.atlassian.net"
AUTH=$(echo -n "$JIRA_EMAIL:$JIRA_API_TOKEN" | base64)

curl -s "https://$JIRA_DOMAIN/rest/api/3/issue/PROJ-123" \
  -H "Authorization: Basic $AUTH" \
  -H "Content-Type: application/json"
```

## Reference Files

- **`references/api-endpoints.md`** - Complete REST API v3 endpoint reference
- **`references/jql-reference.md`** - JQL operators, functions, fields, and patterns
- **`references/adf-format.md`** - Atlassian Document Format for rich text fields

## Common Patterns

### Bulk Operations

To get multiple issues efficiently:

```bash
python scripts/jira_api.py GET /search --query "jql=key in (PROJ-1,PROJ-2,PROJ-3)"
```

### Get Project Info

To list projects or get project details:

```bash
python scripts/jira_api.py GET /project
python scripts/jira_api.py GET /project/PROJ
```

### Get Available Issue Types

```bash
python scripts/jira_api.py GET "/project/PROJ?expand=issueTypes"
```

## Error Handling

Common error codes:

- **400**: Bad request - check JSON syntax and field names
- **401**: Unauthorized - verify credentials
- **403**: Forbidden - check user permissions
- **404**: Not found - verify issue key exists
- **429**: Rate limited - wait and retry

For field validation errors, Jira returns detailed error messages indicating which fields are invalid.

Overview

This skill provides a Jira Cloud integration for managing and searching issues via REST API v3 and JQL. It streamlines common workflows like retrieving issue details, creating and updating issues, adding comments, assigning users, and transitioning issue status. Use it to automate ticket operations and run JQL-based searches programmatically.

How this skill works

The skill calls Jira Cloud REST endpoints using basic auth (email + API token) against your JIRA_DOMAIN. It supports direct HTTP methods (GET, POST, PUT) for endpoints such as /issue, /search, /project and uses Jira Query Language (JQL) for complex searches. Rich text fields and comments use Atlassian Document Format (ADF) where required.

When to use it

  • Retrieve full issue details or selected fields for a ticket
  • Search issues with JQL to build dashboards or reports
  • Create new issues with structured ADF descriptions
  • Update fields, labels, or assignees on existing issues
  • Add comments or transition issue status as part of workflows

Best practices

  • Store JIRA_DOMAIN, JIRA_EMAIL, and JIRA_API_TOKEN in environment variables or a secure vault
  • Use JQL for efficient bulk retrieval instead of repeated single-issue calls
  • Provide ADF-formatted payloads for description and comment bodies to preserve rich text
  • Query available transitions before posting a transition to avoid invalid transition IDs
  • Handle common HTTP errors (400, 401, 403, 404, 429) and parse Jira's field validation messages

Example use cases

  • Automate creation of sprint tasks with prefilled ADF descriptions and labels
  • Run daily JQL reports for 'assignee = currentUser() AND resolution = Unresolved' to notify engineers
  • Bulk-update labels or summary fields for a list of issue keys via /search and PUT
  • Add standardized comments from CI/CD pipelines when deployments reference Jira tickets
  • Transition issues to 'Done' after successful automated test runs using available transition IDs

FAQ

How do I authenticate requests?

Authenticate using basic auth with your Jira email and an API token. Store them in JIRA_EMAIL and JIRA_API_TOKEN and use JIRA_DOMAIN for the base URL.

When should I use ADF vs plain text?

Use ADF for description and comment bodies when you need rich text, lists, or formatting. Simple plain-text fields can be sent as regular JSON strings where supported.

How can I find valid transition IDs for an issue?

Call GET /issue/{issueIdOrKey}/transitions to list available transitions and their IDs before posting a transition.