
jira
JIRA workflow management plugin for Red Hat AI development workflows
- version
- 0.3.0
Install
/plugin install jira@cc-jira-marketplaceRun it inside Claude Code after adding the marketplace with /plugin marketplace add rhuss/cc-jira.
Contents
Discovered from sourceSkills 4
JIRA Integration Patterns
This skill provides comprehensive knowledge about JIRA API usage, JQL query patterns, and best practices for Red Hat AI JIRA integration.
JQL (JIRA Query Language) Reference
Basic Syntax
field operator value [AND|OR field operator value] [ORDER BY field direction]
Common Operators
| Operator | Description | Example |
|---|---|---|
| = | Equals | status = "In Progress" |
| != | Not equals | status != Closed |
| IN | Match any value | project IN (RHAISTRAT, RHOAISTRAT) |
| NOT IN | Exclude values | status NOT IN (Closed, Resolved) |
| ~ | Contains text | summary ~ "authentication" |
| !~ | Does not contain | summary !~ "deprecated" |
| IS EMPTY | Field is empty | assignee IS EMPTY |
| IS NOT EMPTY | Field has value | sprint IS NOT EMPTY |
| > < >= <= | Comparison | created > -7d |
Functions
| Function | Description | Example |
|---|---|---|
currentUser() | Current logged-in user | assignee = currentUser() |
now() | Current date/time | updated > now(-1h) |
startOfDay() | Start of day | created >= startOfDay() |
endOfDay() | End of day | due <= endOfDay() |
startOfWeek() | Start of week | created >= startOfWeek() |
membersOf() | Group members | assignee IN membersOf("team-ai") |
Date Formats
-1d- 1 day ago-2w- 2 weeks ago-3M- 3 months ago-1y- 1 year ago-30m- 30 minutes ago2025-01-15- Specific date
Essential JQL Queries for Red Hat AI
My Work
All my assigned issues (unresolved):
assignee = currentUser() AND resolution = Unresolved ORDER BY priority DESC, updated DESC
My issues updated today:
assignee = currentUser() AND updated >= startOfDay() ORDER BY updated DESC
My overdue issues:
assignee = currentUser() AND due < now() AND resolution = Unresolved ORDER BY due ASC
Sprint Queries
Issues in specific sprint:
sprint = "Sprint 25" ORDER BY rank ASC
Issues in current/active sprint:
sprint IN openSprints() AND project = RHAISTRAT ORDER BY rank ASC
Issues not in any sprint (backlog):
sprint IS EMPTY AND project = RHAISTRAT AND resolution = Unresolved ORDER BY priority DESC
Epic Queries
All stories/tasks in an epic:
parent = RHAISTRAT-123 ORDER BY rank ASC
Epics without children:
issuetype = Epic AND issueFunction IN issuesWithoutSubtasks() ORDER BY created DESC
Progress on epic:
parent = RHAISTRAT-123 AND status = Done
Project-Specific Queries
STRAT features needing refinement:
project IN (RHAISTRAT, RHOAISTRAT) AND status = "Refinement In Progress" ORDER BY updated ASC
RFEs pending approval:
project IN (RHAIRFE, RHELAIRFE, RHOAIRFE) AND status = "Pending Review" ORDER BY created DESC
Engineering issues by component:
project = RHAIENG AND component = "Authentication" AND resolution = Unresolved ORDER BY priority DESC
Advanced Queries
Issues with specific label:
labels = requires_architecture_review AND resolution = Unresolved ORDER BY priority DESC
Issues linked to specific issue:
issue IN linkedIssues(RHAISTRAT-123) ORDER BY type ASC
Recently commented issues:
project = RHAISTRAT AND comment ~ "review" AND updated >= -3d ORDER BY updated DESC
Issues by multiple criteria:
project IN (RHAISTRAT, RHOAISTRAT)
AND assignee = currentUser()
AND status IN ("In Progress", "Code Review")
AND sprint IN openSprints()
ORDER BY priority DESC, rank ASC
Field Mappings
Standard Fields
| Field | API Name | Type | Example Value |
|---|---|---|---|
| Summary | summary | String | "Add authentication support" |
| Description | description | String (formatted) | "As a user, I want..." |
| Status | status.name | String | "In Progress" |
| Priority | priority.name | String | "High" |
| Assignee | assignee.name | String | "jdoe" |
| Reporter | reporter.name | String | "jsmith" |
| Issue Type | issuetype.name | String | "Feature" |
| Project | project.key | String | "RHAISTRAT" |
| Labels | labels | Array | ["documentation", "security"] |
| Components | components | Array of objects | [{"name": "UXD"}] |
| Fix Versions | fixVersions | Array of objects | [{"name": "1.5.0"}] |
Custom Fields (Red Hat AI)
| Field | API Name | Type | Notes |
|---|---|---|---|
| Sprint | customfield_xxxxx | Sprint object | Find ID via API |
| Story Points | customfield_xxxxx | Number | Estimate |
| Epic Link | customfield_xxxxx | String | Epic key |
| Feature Owner | customfield_xxxxx | User object | STRAT features |
| Delivery Owner | customfield_xxxxx | User object | STRAT features |
| Product Documentation Required | customfield_xxxxx | Boolean | Yes/No |
| Requires Architecture Review | customfield_xxxxx | Boolean | Yes/No |
Note: Custom field IDs vary by JIRA instance. Use /rest/api/2/field endpoint to discover actual IDs.
Status Transitions
Standard Workflow
New → In Progress → Code Review → Testing → Done
↓
Blocked
↓
In Progress
STRAT Workflow
Not Started → Refinement In Progress → Refinement Complete → In Development → Testing → Done
↓
Blocked
↓
Refinement In Progress
Transition Best Practices
-
Always check available transitions before attempting:
python jira_client.py get_transitions RHAISTRAT-123 -
Use transition IDs, not names (names can vary):
python jira_client.py transition_issue RHAISTRAT-123 "31" -
Required fields may vary by transition - check transition metadata
-
Add comments when transitioning to provide context
Issue Linking
Link Types
| Link Type | Meaning | Example |
|---|---|---|
| Relates | General relation | Feature relates to another feature |
| Blocks | Blocks progress | Bug blocks feature |
| Clones | Copied from | STRAT clones RFE |
| Duplicates | Same issue | Bug duplicates earlier bug |
| Causes | Root cause | Issue causes another issue |
| Depends on | Dependency | Feature depends on infrastructure |
Linking Patterns
Link STRAT to RFE:
python jira_client.py link_issue RHAISTRAT-123 RHAIRFE-456 "Clones"
Link feature to epic:
# Set parent field instead of link
python jira_client.py update_issue RHAISTRAT-123 '{"parent": {"key": "RHAISTRAT-100"}}'
Link blocker:
python jira_client.py link_issue RHAISTRAT-123 RHAIENG-789 "Blocks"
API Best Practices
Pagination
For large result sets, use pagination:
# First page
startAt=0&maxResults=50
# Next page
startAt=50&maxResults=50
Rate Limiting
- Self-hosted JIRA: Typically no rate limits, but be considerate
- Cloud JIRA: Limits vary by plan
- Use caching to reduce API calls (jira has 4-hour default cache)
Caching Strategy
When to use cache:
- ✅ Viewing issue lists
- ✅ Reading issue details
- ✅ JQL queries for display
When to bypass cache:
- ❌ After making updates
- ❌ Checking current status before transitions
- ❌ Real-time status monitoring
Bypass cache:
python jira_client.py get_issue RHAISTRAT-123 --no-cache
Error Handling
Common errors:
401 Unauthorized- Invalid credentials403 Forbidden- Insufficient permissions404 Not Found- Issue doesn't exist400 Bad Request- Invalid field or value
Best practices:
- Validate issue keys before API calls
- Check user permissions
- Validate field values against JIRA schema
- Handle network errors gracefully
Bulk Operations
Batch Issue Updates
For multiple issues, iterate and update one at a time (no batch update in basic API):
for issue in RHAISTRAT-123 RHAISTRAT-124 RHAISTRAT-125; do
python jira_client.py add_comment "$issue" "Batch update: moving to sprint"
done
Bulk JQL Export
Get all issues matching criteria:
python jira_client.py query_jql "project = RHAISTRAT AND sprint = 'Sprint 25'" > sprint_issues.json
Performance Tips
Optimize JQL Queries
❌ Slow:
summary ~ "authentication" OR description ~ "authentication"
✅ Fast:
text ~ "authentication"
❌ Slow (searches all issues):
assignee = "jdoe"
✅ Fast (limits by project first):
project = RHAISTRAT AND assignee = "jdoe"
Field Selection
Request only needed fields:
# In API calls, use fields parameter
fields=summary,status,assignee,priority
Use Filters
Create saved filters for common queries and reference by ID:
filter = 12345
Integration with Commands
/jira:my-issues
Uses:
assignee = currentUser() AND resolution = Unresolved ORDER BY priority DESC
/jira:sprint
Uses:
sprint = <sprint-id> ORDER BY rank ASC
With current sprint default from config.
/jira:analyze
Combines:
get_issueto fetch issue- Code repository analysis
- Web search if needed
/jira:update
Uses:
get_transitionsto show optionsupdate_issuefor field changesadd_commentfor commentstransition_issuefor status changes
Troubleshooting
Issue: JQL query returns no results
- Verify project key exists
- Check field names (case-sensitive)
- Simplify query to isolate problem
Issue: Can't update field
- Check field permissions
- Verify field is not read-only
- Check required field validation
Issue: Transition not available
- Check current status
- Verify workflow allows transition
- Check user permissions for transition
Issue: Slow queries
- Add project filter
- Use indexed fields (status, priority, assignee)
- Avoid text searches on large instances
References:
- Atlassian JQL Documentation: https://support.atlassian.com/jira-software-cloud/docs/use-advanced-search-with-jira-query-language-jql/
- JIRA REST API: https://docs.atlassian.com/software/jira/docs/api/REST/latest/
- Plugin JIRA Client:
scripts/jira_client.py
JIRA JQL Translation Skill
When users search JIRA with natural language queries, use this skill to generate appropriate JQL (JIRA Query Language) queries that are syntactically correct, semantically meaningful, and performant.
Core Translation Principles
- Understand Intent: Interpret what the user wants to find
- Apply Smart Defaults: Use fuzzy matching and expansions for common patterns
- Prioritize Performance: Always include project filters when possible
- Be Transparent: Generate clear, readable JQL that users can learn from
- Add Context: Include sensible ORDER BY clauses for immediate usefulness
Translation Patterns
Fuzzy Status Matching
Users rarely know exact status names. Apply intelligent fuzzy matching:
"open" / "opened" / "active" / "not done":
status IN (Open, 'To Do', 'In Progress', 'Refinement In Progress', New, Blocked)
"closed" / "done" / "finished" / "completed":
status IN (Closed, Done, Resolved, 'Refinement Complete')
"in progress" / "working on" / "active development":
status IN ('In Progress', 'Code Review', Testing, 'Refinement In Progress')
"blocked" / "stuck" / "waiting":
status IN (Blocked, Waiting, 'Pending Review', 'Pending Approval')
"needs review" / "ready for review":
status IN ('Code Review', 'Pending Review', 'Ready for QA')
Release/Version Queries
Teams use both fixVersion field AND labels inconsistently. Always check both automatically:
"release-3.2" / "version 3.2" / "3.2 release":
(fixVersion = 'release-3.2' OR labels = 'release-3.2')
"targeted to X" / "planned for X":
(fixVersion = 'X' OR labels = 'X')
Pattern: Always use OR to check both fixVersion and labels for any version/release query.
Link Following
"linked to RHAISTRAT-123" / "related to RHAI-456":
issue IN linkedIssues(RHAISTRAT-123)
"blocks RHAIENG-789" / "blocking KEY":
issue IN linkedIssues(RHAIENG-789, "blocks")
"blocked by KEY":
issue IN linkedIssues(KEY, "is blocked by")
"depends on KEY":
issue IN linkedIssues(KEY, "depends on")
Common link types: Relates, Blocks, Clones, Duplicates, Causes, Depends on
Ownership Queries
"my issues" / "assigned to me" / "mine":
assignee = currentUser()
"created by me" / "I created" / "I reported":
reporter = currentUser()
"unassigned" / "no assignee" / "needs owner":
assignee IS EMPTY
"assigned to john" / "john's issues":
assignee = john
Note: Usernames in JIRA are typically lowercase, without spaces.
Priority Queries
"high priority" / "urgent" / "critical":
priority IN (Highest, High, Critical)
"low priority":
priority IN (Lowest, Low)
"medium priority" / "normal":
priority = Medium
Issue Type Queries
"bugs" / "defects":
issuetype = Bug
"features" / "stories" / "user stories":
issuetype IN (Feature, Story, 'User Story')
"tasks" / "chores":
issuetype = Task
"epics":
issuetype = Epic
"subtasks" / "sub-tasks":
issuetype IN subTaskIssueTypes()
Date/Time Queries
"last week" / "past week" / "this week":
updated >= -7d
"yesterday" / "last 24 hours":
updated >= -1d
"last month":
updated >= -30d
"today" / "updated today":
updated >= startOfDay()
"created this month":
created >= startOfMonth()
"overdue":
due < now() AND resolution = Unresolved
Sprint Queries
"current sprint" / "active sprint":
sprint IN openSprints()
"no sprint" / "backlog" / "not in any sprint":
sprint IS EMPTY
"sprint 25" / "sprint X":
sprint = X
Team/Group Queries
"assigned to the QA team" / "QA's issues":
assignee IN membersOf("qa") OR assignee IN membersOf("quality-assurance")
"created by the dev team":
reporter IN membersOf("developers")
Label Queries
"labeled X" / "tagged X" / "with label X":
labels = X
"requires architecture review":
labels = requires_architecture_review
Note: Labels are typically lowercase with underscores or hyphens.
Resolution Queries
"unresolved" / "not done" / "still open":
resolution = Unresolved
"resolved" / "fixed":
resolution IS NOT EMPTY
JQL Syntax Reference
Operators
| Operator | Usage | Example |
|---|---|---|
= | Equals (exact match) | status = Open |
!= | Not equals | priority != Low |
> | Greater than | votes > 10 |
>= | Greater or equal | created >= -7d |
< | Less than | votes < 5 |
<= | Less or equal | duedate <= now() |
IN | Matches any value in list | status IN (Open, 'In Progress') |
NOT IN | Excludes all values in list | status NOT IN (Closed, Done) |
~ | Contains (text search) | summary ~ "authentication" |
!~ | Does not contain | summary !~ "deprecated" |
IS EMPTY | Field has no value | assignee IS EMPTY |
IS NOT EMPTY | Field has a value | labels IS NOT EMPTY |
IS NULL | Same as IS EMPTY | fixVersion IS NULL |
IS NOT NULL | Same as IS NOT EMPTY | component IS NOT NULL |
WAS | Had value in the past | status WAS 'In Progress' |
WAS IN | Was any of values | status WAS IN (Open, New) |
WAS NOT | Was not value | assignee WAS NOT john |
CHANGED | Field value changed | priority CHANGED |
Functions
| Function | Description | Example |
|---|---|---|
currentUser() | Currently logged-in user | assignee = currentUser() |
linkedIssues(key) | All issues linked to key | issue IN linkedIssues(RHAI-123) |
linkedIssues(key, linkType) | Issues with specific link type | issue IN linkedIssues(RHAI-123, "blocks") |
membersOf(group) | Users in a group | assignee IN membersOf("developers") |
now() | Current date/time | created > now(-1h) |
startOfDay([offset]) | Start of today (or offset) | created >= startOfDay() |
endOfDay([offset]) | End of today (or offset) | due <= endOfDay() |
startOfWeek([offset]) | Start of week | created >= startOfWeek() |
endOfWeek([offset]) | End of week | due <= endOfWeek() |
startOfMonth([offset]) | Start of month | created >= startOfMonth() |
endOfMonth([offset]) | End of month | due <= endOfMonth() |
startOfYear([offset]) | Start of year | created >= startOfYear() |
endOfYear([offset]) | End of year | resolved <= endOfYear() |
openSprints() | All active sprints | sprint IN openSprints() |
closedSprints() | All completed sprints | sprint IN closedSprints() |
futureSprints() | All future sprints | sprint IN futureSprints() |
subTaskIssueTypes() | All subtask types | issuetype IN subTaskIssueTypes() |
issueHistory() | Search issue history | Advanced usage |
Time offset examples:
now(-1h)- 1 hour agostartOfDay(-7)- Start of day 7 days agostartOfMonth(1)- Start of next month
Fields
| Field | Description | Example Values |
|---|---|---|
project | Project key | RHAISTRAT, RHAIENG, RHAIRFE |
summary | Issue title | "Add authentication support" |
description | Issue description | Free text |
issuetype | Type of issue | Bug, Feature, Story, Task, Epic |
status | Current status | Open, 'In Progress', Done, Closed |
priority | Priority level | Highest, High, Medium, Low, Lowest |
assignee | Assigned user | jdoe, currentUser() |
reporter | Created by | jsmith, currentUser() |
created | Creation date | "2025-01-15", -7d |
updated | Last updated | -1d, startOfDay() |
resolved | Resolution date | -30d, now() |
due | Due date | "2025-02-01", endOfWeek() |
labels | Tags/labels | documentation, security |
component | Component | Authentication, UXD, API |
fixVersion | Target version | 1.5.0, release-3.2 |
affectsVersion | Found in version | 1.4.0 |
resolution | Resolution status | Unresolved, Fixed, Won't Fix |
sprint | Sprint | Sprint 25, openSprints() |
comment | Issue comments | Free text search |
votes | Number of votes | 10, >5 |
watchers | Number of watchers | 3, >=1 |
text | All text fields | Searches summary, description, comments |
Logical Operators
| Operator | Usage | Example |
|---|---|---|
AND | All conditions must be true | project = RHAI AND status = Open |
OR | Any condition must be true | priority = High OR priority = Highest |
NOT | Negates a condition | NOT status = Closed |
Parentheses for grouping:
(priority = High OR priority = Highest) AND status = Open
Ordering
ORDER BY sorts results:
ORDER BY priority DESC
ORDER BY created ASC
ORDER BY priority DESC, updated DESC
Directions: ASC (ascending), DESC (descending)
Quoting Rules
Quote multi-word values with single or double quotes:
status = 'In Progress'
status = "Code Review"
project IN (RHAI, RHAIENG) # Single-word values don't need quotes
Quote special characters:
summary ~ "user's authentication"
Date Formats
Relative dates:
-1d- 1 day ago-2w- 2 weeks ago-3M- 3 months ago-1y- 1 year ago-30m- 30 minutes ago-2h- 2 hours ago
Absolute dates:
"2025-01-15""2025/01/15""15/Jan/25"
Functions:
now()startOfDay(),endOfDay()startOfWeek(),endOfWeek()
Complex Translation Examples
Example 1: "my open bugs in RHAIENG"
User Intent: Find bugs assigned to me that aren't finished yet, in a specific project
Generated JQL:
project = RHAIENG
AND issuetype = Bug
AND assignee = currentUser()
AND status IN (Open, 'To Do', 'In Progress', New, Blocked)
ORDER BY priority DESC, updated DESC
Why:
- Project filter first (performance)
- Fuzzy status matching ("open" → multiple statuses)
- Sensible ordering (high priority first, then recently updated)
Example 2: "features targeted to release-3.2 that are still open"
User Intent: Find features planned for a release that aren't done yet
Generated JQL:
issuetype IN (Feature, Story, 'User Story')
AND (fixVersion = 'release-3.2' OR labels = 'release-3.2')
AND status NOT IN (Done, Closed, Resolved, 'Refinement Complete')
ORDER BY priority DESC
Why:
- Checks both fixVersion and labels (teams use inconsistently)
- Excludes "closed" statuses (fuzzy matching)
- Orders by priority for focus
Example 3: "issues linked to RHAISTRAT-123"
User Intent: Find all issues with any link to a specific issue
Generated JQL:
issue IN linkedIssues(RHAISTRAT-123)
ORDER BY type ASC, key ASC
Why:
- Uses linkedIssues() function
- Orders by type for grouping (bugs, features, etc.)
Example 4: "my issues updated in the last week"
User Intent: Find my issues with recent activity
Generated JQL:
assignee = currentUser()
AND updated >= -7d
ORDER BY updated DESC
Why:
- Simple and direct
- Orders by most recent first
Example 5: "unassigned high priority bugs in RHAIENG"
User Intent: Find urgent bugs that need an owner
Generated JQL:
project = RHAIENG
AND issuetype = Bug
AND priority IN (Highest, High, Critical)
AND assignee IS EMPTY
ORDER BY priority DESC, created DESC
Why:
- Project filter first
- Fuzzy priority matching ("high priority" → multiple levels)
- Orders by priority then age
Example 6: "bugs created by me that block other issues"
User Intent: Find bugs I reported that are blockers
Generated JQL:
issuetype = Bug
AND reporter = currentUser()
AND issue IN linkedIssues(*, "blocks")
ORDER BY created DESC
Note: The * wildcard with linkedIssues may not work in all JIRA versions. Alternative approach:
issuetype = Bug
AND reporter = currentUser()
ORDER BY created DESC
Then filter manually for blockers.
Example 7: "features in the current sprint assigned to the QA team"
User Intent: Find features in active sprint assigned to QA
Generated JQL:
issuetype IN (Feature, Story)
AND sprint IN openSprints()
AND (assignee IN membersOf("qa") OR assignee IN membersOf("quality-assurance"))
ORDER BY rank ASC
Why:
- Uses openSprints() for current sprint
- Checks multiple possible group names
- Orders by rank (sprint order)
Example 8: "my overdue tasks"
User Intent: Find tasks assigned to me that are past due date
Generated JQL:
assignee = currentUser()
AND due < now()
AND resolution = Unresolved
ORDER BY due ASC
Why:
- Checks due date is in the past
- Excludes resolved issues
- Orders by most overdue first
Example 9: "issues created this month in RHAISTRAT project with no labels"
User Intent: Find recent issues that haven't been tagged yet
Generated JQL:
project = RHAISTRAT
AND created >= startOfMonth()
AND labels IS EMPTY
ORDER BY created DESC
Why:
- Uses startOfMonth() for "this month"
- IS EMPTY for "no labels"
- Recent first ordering
Example 10: "bugs in release-2.5 that were closed but are now reopened"
User Intent: Find regressions in a specific release
Generated JQL:
issuetype = Bug
AND (fixVersion = 'release-2.5' OR labels = 'release-2.5')
AND status WAS Closed
AND status = Open
ORDER BY updated DESC
Why:
- Uses WAS operator for history
- Checks both version field and labels
- Current status is Open (reopened)
Translation Guidelines
1. Always Include Project Filters When Possible
Bad (slow, searches all issues):
assignee = currentUser() AND status = Open
Good (fast, limits scope):
project = RHAIENG AND assignee = currentUser() AND status = Open
Performance: 10-100x faster with project filter.
2. Use Fuzzy Matching for Status and Priority
Don't require users to know exact status names. Map common terms to multiple statuses:
- "open" → Open, To Do, In Progress, New
- "high priority" → Highest, High, Critical
3. Always Expand Release Queries
Check both fixVersion AND labels automatically:
(fixVersion = 'X' OR labels = 'X')
4. Add Sensible ORDER BY Clauses
Don't return unordered results. Choose ordering based on intent:
- Priority:
ORDER BY priority DESC - Recency:
ORDER BY updated DESCorORDER BY created DESC - Due date:
ORDER BY due ASC - Sprint:
ORDER BY rank ASC
5. Quote Multi-Word Values
status = 'In Progress' # Correct
status = In Progress # Wrong (syntax error)
6. Prefer Positive Conditions
Less clear:
NOT status = Closed
More clear:
status IN (Open, 'In Progress', 'To Do')
7. Use Functions for Dynamic Values
Static (becomes outdated):
assignee = jdoe
Dynamic (works for any user):
assignee = currentUser()
8. Combine Related Conditions
Verbose:
status = Open OR status = 'In Progress' OR status = 'To Do'
Concise:
status IN (Open, 'In Progress', 'To Do')
9. Be Explicit About Intent
If user says "my bugs", include:
- issuetype = Bug
- assignee = currentUser()
- Likely want: status IN (open statuses)
- Good ordering: priority DESC
10. Handle Ambiguity with Sensible Defaults
If query is vague like "issues", default to:
assignee = currentUser() AND resolution = Unresolved
ORDER BY updated DESC
Assume user wants their own open issues.
Common Patterns Quick Reference
| User Says | Generate JQL |
|---|---|
| "my issues" | assignee = currentUser() AND resolution = Unresolved |
| "my bugs" | issuetype = Bug AND assignee = currentUser() AND status IN (...) |
| "my open bugs" | Above + fuzzy status |
| "bugs in PROJECT" | project = PROJECT AND issuetype = Bug |
| "high priority" | priority IN (Highest, High, Critical) |
| "release-X" | (fixVersion = 'release-X' OR labels = 'release-X') |
| "last week" | updated >= -7d |
| "today" | updated >= startOfDay() |
| "unassigned" | assignee IS EMPTY |
| "created by me" | reporter = currentUser() |
| "overdue" | due < now() AND resolution = Unresolved |
| "current sprint" | sprint IN openSprints() |
| "linked to KEY" | issue IN linkedIssues(KEY) |
| "no labels" | labels IS EMPTY |
Performance Optimization Tips
1. Project Filter First
Always include project in queries when possible.
2. Avoid Text Searches When Possible
Slow:
summary ~ "authentication" OR description ~ "authentication"
Faster:
text ~ "authentication" # Searches summary, description, comments
Even better (if possible):
labels = authentication # Field match is fastest
3. Limit OR Conditions
Slower:
project = A OR project = B OR project = C OR ... # Many ORs
Faster:
project IN (A, B, C, ...) # Single IN clause
4. Use Indexed Fields
Prefer these (indexed in most JIRA instances):
- project
- status
- priority
- assignee
- reporter
- issuetype
Avoid heavy reliance on:
- text searches (
~operator) - comments
- description
Error Prevention
Common Mistakes to Avoid
1. Missing Quotes:
status = In Progress # WRONG (syntax error)
status = 'In Progress' # CORRECT
2. Wrong Operator for Field Type:
created ~ "2025-01-15" # WRONG (~ is for text)
created = "2025-01-15" # CORRECT (= for dates)
3. Using != with Text Fields:
summary != "test" # NOT SUPPORTED
NOT summary ~ "test" # Use this instead
4. Case Sensitivity:
- Field names: Case-insensitive (
status=Status=STATUS) - Values: Case-sensitive (
status = Open≠status = open) - Functions: Case-insensitive
5. Reserved Words: Don't use these as unquoted values: AND, OR, NOT, EMPTY, NULL, ORDER, BY
Web References
For the most up-to-date JQL documentation:
- Advanced Search Guide: https://support.atlassian.com/jira-software-cloud/docs/use-advanced-search-with-jira-query-language-jql/
- JQL Fields Reference: https://support.atlassian.com/jira-software-cloud/docs/jql-fields/
- JQL Operators: https://support.atlassian.com/jira-software-cloud/docs/jql-operators/
- JQL Functions: https://support.atlassian.com/jira-software-cloud/docs/jql-functions/
- JQL Cheat Sheet: https://www.atlassian.com/software/jira/guides/jql/cheat-sheet
- linkedIssues Function: Check Atlassian documentation for link type names in your JIRA instance
Usage in /jira:search Command
When the /jira:search command invokes this skill, you should:
- Parse the user's natural language query
- Identify key components (project, issue type, status, owner, etc.)
- Apply fuzzy matching and smart expansions
- Construct syntactically correct JQL
- Add sensible ORDER BY clause
- Return the JQL string only (no explanation in the JQL itself)
The command will show the JQL to the user with an explanation before execution.
Example workflow:
User query: "my open bugs in RHAIENG"
Your thought process:
- "my" → assignee = currentUser()
- "bugs" → issuetype = Bug
- "in RHAIENG" → project = RHAIENG
- "open" → status IN (Open, 'To Do', 'In Progress', New, Blocked)
- Add ordering → ORDER BY priority DESC, updated DESC
Generated JQL:
project = RHAIENG AND issuetype = Bug AND assignee = currentUser() AND status IN (Open, 'To Do', 'In Progress', New, Blocked) ORDER BY priority DESC, updated DESC
Remember: Your goal is to translate user intent into powerful, correct, performant JQL. Be smart, be helpful, and always think about what the user really wants to find.
JIRA Workflows for Red Hat AI
This skill provides comprehensive knowledge about Red Hat AI story type workflows, including STRAT feature refinement and RFE processes.
Story Types
Red Hat AI uses different story types, each with specific workflows:
- STRAT (Strategic Features) - RHAISTRAT, RHOAISTRAT
- RFE (Request for Enhancement) - RHAIRFE, RHELAIRFE, RHOAIRFE
- RHAIENG - Engineering stories
- Standard Stories - Regular development work
STRAT Feature Refinement Workflow
Overview
Timeline: 1 week from initial doc creation to completion
Dashboard: https://issues.redhat.com/secure/Dashboard.jspa?selectPageId=12386400
Projects:
- RHAISTRAT - Red Hat AI Strategic Features
- RHOAISTRAT - Red Hat OpenShift AI Strategic Features
Process Steps
1. Initial Setup
Ensure the RFE has been approved and properly cloned:
- Clone to relevant STRAT projects as a 'Feature':
- RHAISTRAT
- RHOAISTRAT
- Ensure Feature is properly linked to the associated RFE:
- RHAIRFE-xxx
- RHELAIRFE-xxx
- RHOAIRFE-xxx
2. Feature Refinement Document Creation
Create the document:
- Create a copy of the feature refinement template
- Name format:
FeatureRefinement - RHAISTRAT-# - TITLE OF FEATURE - Store in feature refinement documents folder (location configurable)
Document Workflow:
- PM and PO/Staff Eng fill in their sections first
- Rest of team and stakeholders provide answers in their sections:
- Scrum Team Engineers
- UX
- Docs
- QE
- Other pillar stakeholders:
- AIPCC (AI Platform Components & Capabilities)
- RHAIIS (Red Hat AI Inference Service)
- AI Platforms (RHOAI)
- Perf / Scale
- Support
- Technical Marketing
3. Key Sections in Refinement Document
Metadata:
- Feature JIRA link
- Status (Not started / In Progress / Complete)
- Slack channel/thread
- Feature Owner, Delivery Owner, RFE Council Reviewer
- Product (RHOAI managed/self-managed, RHAIIS, RHEL AI)
Feature Details:
- Feature Overview (Who benefits, current state vs future state, user narrative)
- The Why (Why now, what value, customer impact, supporting data)
- High Level Requirements (As a [role], I want [capability], So that [benefit])
- Non-Functional Requirements (performance, security, disconnected env, upgrades)
- Out-of-Scope (Define boundaries)
- Acceptance Criteria (Given/When/Then format)
- Risks & Assumptions
- Supporting Documentation (links to designs, workflows, wireframes, technical docs)
Prerequisites & Dependencies:
- Architecture Review Check
- ODH/RHOAI Build Process Onboarding
- License Validation
- Accelerator/Package Support (AIPCC)
- Documentation Support
- UXD Support
- Additional dependencies
High Level Plan:
- Teams involved in delivery
- Start dates
- Work to deliver (EPICs)
- Team dependencies
- T-shirt size estimates
- Approvals/comments
4. Approval & Finalization
- Get approval from all relevant stakeholders in the refinement doc
- Copy information from refinement doc to associated JIRA feature
- Link the refinement doc in the JIRA issue (add comment with path)
- Mark refinement doc as 'Final' in title
- Make document 'Read Only' (by JIRA owner)
Best Practices
- Timeline compliance: Complete within 1 week
- Stakeholder engagement: Ensure all required teams are consulted
- Architecture review: Required if label "requires_architecture_review" is set
- License validation: Preference is Apache 2.0
- Documentation: Always link, never copy content
- Clarity: Use clear, testable acceptance criteria
RFE (Request for Enhancement) Process
Overview
RFE is the process for requesting significant new features or enhancements to Red Hat AI products.
Projects:
- RHAIRFE - Red Hat AI RFE
- RHELAIRFE - RHEL AI RFE
- RHOAIRFE - Red Hat OpenShift AI RFE
Process (High Level)
Note: Detailed RFE process will be added when the RFE Council Charter document is processed.
Key Stages
- Submission: RFE submitted to appropriate project
- Council Review: RFE Council reviews and approves/rejects
- Cloning to STRAT: Approved RFEs cloned as STRAT features
- Feature Refinement: Follow STRAT refinement process
- Implementation: Execute based on refinement plan
RFE to STRAT Linkage
- Approved RFEs must be cloned to STRAT projects (RHAISTRAT, RHOAISTRAT)
- STRAT feature must link back to original RFE
- Link types: "clones", "is cloned by", "relates to"
Common JIRA Fields for Red Hat AI
Story Types
- Feature: High-level capability (STRAT issues)
- Story: Implementation work
- Epic: Collection of related features/stories
- Bug: Defects and issues
- Task: General work items
Custom Fields
- Product Documentation Required: Yes/No
- Requires Architecture Review: Yes/No
- Feature Owner: Person responsible
- Delivery Owner: Engineering lead
- Sprint: Current sprint assignment
- Release: Target release version
- Components: UXD, Documentation, AIPCC, etc.
Labels (Common)
requires_architecture_reviewdocumentationuxdperformancesecuritydisconnectedupstream
Status Transitions
Typical Flow:
- New/Open
- In Progress
- Code Review
- Testing/QE
- Done/Closed
STRAT-Specific:
- Not Started
- Refinement In Progress
- Refinement Complete
- In Development
- Done
JQL Patterns for Red Hat AI
Find My STRAT Features
project IN (RHAISTRAT, RHOAISTRAT) AND assignee = currentUser() AND resolution = Unresolved ORDER BY priority DESC
Find RFEs Pending Review
project IN (RHAIRFE, RHELAIRFE, RHOAIRFE) AND status = "Pending Review" ORDER BY created DESC
Find Features Needing Refinement
project IN (RHAISTRAT, RHOAISTRAT) AND status = "Refinement In Progress" ORDER BY updated ASC
Find Issues Requiring Architecture Review
labels = requires_architecture_review AND resolution = Unresolved ORDER BY priority DESC
Integration with /jira:strat Command
The /jira:strat command uses this workflow knowledge to:
- Guide users through feature refinement process
- Create refinement documents from template
- Link documents to JIRA issues
- Track stakeholder approvals
- Validate completeness before finalization
Integration with /jira:rfe Command
The /jira:rfe command uses this workflow knowledge to:
- Display RFE details and status
- Show linkage to STRAT features
- Guide through RFE submission (future)
- Track RFE Council review status (future)
Tips for Using Red Hat AI JIRA
- Always link RFEs to STRAT features - Maintain traceability
- Use consistent naming - Follow "FeatureRefinement - STRAT-# - Title" pattern
- Engage stakeholders early - Don't wait until end of refinement period
- Architecture review is mandatory - If label is set, must present to forum
- Document everything - Use JIRA comments and linked docs
- Update status regularly - Keep issue status current
- Watch dependencies - Track AIPCC, UXD, Docs dependencies closely
Troubleshooting
Issue: Can't find STRAT feature for RFE
- Check if RFE is approved
- Look for "clones" link type
- Search both RHAISTRAT and RHOAISTRAT projects
Issue: Refinement taking longer than 1 week
- Identify blockers
- Escalate to Feature Owner
- Document delays in JIRA comments
Issue: Missing stakeholder approval
- Tag stakeholder in refinement doc
- Send Slack message to team channel
- Escalate to Delivery Owner if no response
Last Updated: Based on STRAT_PROCESS.md (2025-12-15)
References:
- STRAT Process: See STRAT_PROCESS.md in plugin root
- RFE Process: To be added from RFE Council Charter document
- Dashboard: https://issues.redhat.com/secure/Dashboard.jspa?selectPageId=12386400
Plugin Environment Setup Skill
This skill handles the bootstrap process for jira plugin commands.
Purpose
Ensures the Python virtual environment is created and dependencies are installed.
The plugin root directory is resolved by the UserPromptSubmit hook (context-hook.py),
which injects <jira-context> into the session. This skill only needs to handle
venv setup.
Task
ALWAYS run this bootstrap FIRST before doing anything else in jira commands.
Step 1: Extract Plugin Root
Extract PLUGIN_ROOT from the <jira-context> system reminder injected by the
UserPromptSubmit hook. Use the value from <plugin-root>.
If <jira-context> is not present, the hook may not have fired. Instruct the user
to verify the plugin is installed correctly.
Step 2: Run setup_env.sh
Execute the plugin's environment setup script:
if [ ! -f "$PLUGIN_ROOT/scripts/setup_env.sh" ]; then
echo "✗ setup_env.sh not found in plugin directory" >&2
exit 1
fi
# Run setup script
bash "$PLUGIN_ROOT/scripts/setup_env.sh"
Step 3: Verify environment
Check that the environment is ready:
VENV_PATH=".claude/jira/venv"
if [ ! -d "$VENV_PATH" ]; then
echo "✗ Virtual environment not created" >&2
exit 1
fi
# Check if Python dependencies are installed
if ! "$VENV_PATH/bin/python" -c "import atlassian" 2>/dev/null; then
echo "⚠ Dependencies may not be fully installed"
echo "Try running: source $VENV_PATH/bin/activate && pip install -r $PLUGIN_ROOT/requirements.txt"
else
echo "✓ jira plugin environment is ready!"
fi
Success Indicators
After running this skill, you should see:
- ✓ Virtual environment created at
.claude/jira/venv - ✓ Python dependencies installed
- ✓ Plugin environment ready for commands
Troubleshooting
If bootstrap fails:
- Ensure Python 3.8+ is installed
- Check that the plugin is properly installed in Claude Code
- Verify write permissions in
.claude/directory - Check internet connectivity for pip install
If dependencies fail to install:
source ".claude/jira/venv/bin/activate"
pip install -r "$PLUGIN_ROOT/requirements.txt" --verbose
Commands 7
You are helping the user set up auto-approval hooks for the jira plugin to reduce the number of permission prompts during JIRA workflows.
Context
The jira plugin frequently needs to:
- Read configuration files (.claude/jira.local.md)
- Search for content patterns (Grep)
- Find files by patterns (Glob)
- Run plugin scripts from scripts/jira_client.py
Without auto-approval hooks, each of these operations may require manual approval, which significantly slows down the workflow.
Task
Step 0: Resolve Plugin Root
Extract PLUGIN_ROOT from the <jira-context> system reminder
injected by the UserPromptSubmit hook. Use the value from <plugin-root>.
Step 1: Configure Auto-Approval
-
Ask the user whether they want to configure auto-approval:
- Globally (in
~/.claude/settings.json) - affects all projects - Project-specific (in
.claude/settings.local.json) - affects only this project - Both
- Globally (in
-
Read the current settings file(s) to check if hooks already exist
-
Merge or create hooks configuration with these auto-approvals:
- Bash commands containing
/scripts/run.shor/scripts/jira_client.py - Bash commands checking for
.claude/jira.local.mdconfiguration file - Bash commands with
/tmp/jira-cache/pattern (cache operations) - Read operations on configuration and script files (.md, .txt, .json, .py, .sh)
- All Grep operations
- All Glob operations
- Bash commands containing
-
Write the updated settings back to the appropriate file(s)
-
Inform the user that:
- Settings have been updated
- They need to restart Claude Code or start a new session for the hooks to take effect
- They can review the hooks in the
/hooksmenu - They can revert by removing the hooks from the settings file
Important Notes
- If the user already has hooks configured, merge the new hooks with existing ones (don't overwrite)
- Preserve all other settings in the file
- Use proper JSON formatting with the correct hook response schema
- The hooks will only auto-approve the specific patterns listed - other operations will still require manual approval
- Hooks read JSON input from stdin using
input=$(cat) - The response MUST be nested under
hookSpecificOutputwithhookEventName: "PreToolUse"
Example Hook Configuration
{
"hooks": {
"PreToolUse": [
{
"matcher": "Bash",
"hooks": [
{
"type": "command",
"command": "input=$(cat); if echo \"$input\" | grep -qE '(/scripts/run\\.sh|/scripts/jira_client\\.py|jira\\.local\\.md|/tmp/jira-cache)'; then echo '{\"hookSpecificOutput\": {\"hookEventName\": \"PreToolUse\", \"permissionDecision\": \"allow\", \"permissionDecisionReason\": \"JIRA plugin script/config auto-approved\"}}'; fi",
"timeout": 5
}
]
},
{
"matcher": "Read",
"hooks": [
{
"type": "command",
"command": "input=$(cat); if echo \"$input\" | grep -qE '\\.(md|txt|json|py|sh)\"'; then echo '{\"hookSpecificOutput\": {\"hookEventName\": \"PreToolUse\", \"permissionDecision\": \"allow\", \"permissionDecisionReason\": \"Configuration/script file read auto-approved\"}}'; fi",
"timeout": 5
}
]
},
{
"matcher": "Grep",
"hooks": [
{
"type": "command",
"command": "echo '{\"hookSpecificOutput\": {\"hookEventName\": \"PreToolUse\", \"permissionDecision\": \"allow\", \"permissionDecisionReason\": \"Grep operations auto-approved\"}}'",
"timeout": 5
}
]
},
{
"matcher": "Glob",
"hooks": [
{
"type": "command",
"command": "echo '{\"hookSpecificOutput\": {\"hookEventName\": \"PreToolUse\", \"permissionDecision\": \"allow\", \"permissionDecisionReason\": \"Glob operations auto-approved\"}}'",
"timeout": 5
}
]
}
]
}
}
Hook Response Schema
For PreToolUse hooks, the output must be valid JSON with this exact structure:
{
"hookSpecificOutput": {
"hookEventName": "PreToolUse",
"permissionDecision": "allow" | "deny" | "ask",
"permissionDecisionReason": "Description shown to user"
}
}
Critical Requirements:
- The response MUST be nested under
hookSpecificOutput - The hook MUST exit with code 0 for the JSON to be processed
- If the hook outputs nothing (empty), default permission logic applies
- The
hookEventNamemust be exactly"PreToolUse"
Auto-Approved Patterns
The following patterns will be automatically approved:
Bash Commands
- Commands containing
/scripts/run.sh(plugin script runner) - Commands containing
/scripts/jira_client.py(main Python script) - Commands checking
.claude/jira.local.md(configuration file) - Commands accessing
/tmp/jira-cache/(cache directory)
Read Operations
- Reading
.md,.txt,.json,.py,.shfiles - Reading configuration and documentation files
Search Operations
- All Grep operations (content search)
- All Glob operations (file pattern matching)
Security Considerations
These hooks are designed to auto-approve only:
- Operations within the jira plugin scope
- Read-only operations on configuration files
- Standard search and file-finding operations
- Cache operations in temporary directory
They will NOT auto-approve:
- Writing to arbitrary files
- Deleting files
- Network operations (these are handled by jira_client.py)
- System-level commands
Begin by asking the user which scope they prefer for the auto-approval configuration.
/jira:my-issues - List Assigned Issues
Display all unresolved JIRA issues assigned to the current user in a formatted table or list.
Task
Step 0: Resolve Plugin Root
Extract PLUGIN_ROOT from the <jira-context> system reminder
injected by the UserPromptSubmit hook. Use the value from <plugin-root>.
Check <jira-configured> - if false, instruct user to run /jira:setup.
Then invoke the setup-plugin-env skill to ensure the venv is ready.
Step 1: List assigned issues
"$PLUGIN_ROOT/scripts/run.sh" jira_client.py my_issues "$@"
Advanced Features
Filtering by Project
/jira:my-issues --project RHAISTRAT
Changing Output Format
/jira:my-issues --format list
/jira:my-issues --format table
Customizing Default JQL
Edit .claude/jira.local.md and modify default_jql_filters:
default_jql_filters: "assignee = currentUser() AND status IN ('In Progress', 'Code Review') ORDER BY priority DESC"
Field Display
Table Format Fields
Row 1:
- Key (e.g., RHAISTRAT-123)
- Status (e.g., In Progress)
- Priority (e.g., High)
- Summary (truncated to 66 chars)
Row 2:
- Reporter
- Assignee
- Labels (truncated to 20 chars)
- Sprint (if available)
- Release/Fix Version
Row 3:
- Clickable JIRA URL
List Format Fields
- Key and Summary
- Status and Priority
- Assignee
- Labels
- JIRA URL
Error Handling
If JIRA not configured:
❌ JIRA not configured. Please run /jira:setup first.
If query fails:
❌ Failed to query JIRA:
[Error message from API]
If no issues found:
✨ No unresolved issues assigned to you!
Great job! 🎉
Performance Notes
- Results are cached for 4 hours (configurable in settings)
- For fresh results, clear cache:
rm -rf /tmp/jira-cache/ - Large result sets (>100 issues) may take a few seconds
Tips
- Quick refresh: Run
/jira:my-issuesanytime to see current status - Filter by project: Use
--projectflag for focused view - Narrow terminal: Automatically switches to list format
- Click links: URLs are clickable in most modern terminals
- Customize JQL: Modify default query in config file for your workflow
Integration
This command integrates with:
- skills/jira-integration.md - Uses JQL patterns and field mappings
- scripts/jira_client.py - Executes my_issues operation
- .claude/jira.local.md - Reads default_jql_filters setting
/jira:search - Natural Language JIRA Search
Search JIRA issues using natural language queries that are automatically translated to powerful JQL (JIRA Query Language) queries.
Examples
/jira:search my open bugs
/jira:search features targeted to release-3.2 that are still open
/jira:search bugs in RHAIENG assigned to the QA team
/jira:search issues linked to RHAISTRAT-123
/jira:search my issues updated in the last week
/jira:search unassigned high priority tasks
/jira:search # Interactive mode - will prompt for query
Task Workflow
Step 0: Resolve Plugin Root
Extract PLUGIN_ROOT from the <jira-context> system reminder
injected by the UserPromptSubmit hook. Use the value from <plugin-root>.
Check <jira-configured> - if false, instruct user to run /jira:setup.
Then invoke the setup-plugin-env skill to ensure the venv is ready.
Step 1: Get Search Query
If query argument was provided:
- Store it in a variable:
SEARCH_QUERY - Proceed to Step 2
If no query argument was provided (interactive mode):
Use AskUserQuestion to get the search query:
Question: What would you like to search for in JIRA?
- Header: "Search Query"
- Options:
- Label: "My open issues" Description: "Issues assigned to me that aren't finished yet"
- Label: "My open bugs" Description: "Bugs assigned to me that need work"
- Label: "High priority items" Description: "High or critical priority issues"
- Label: "Issues in current sprint" Description: "All issues in the active sprint"
- (User can also select "Other" to enter a custom natural language query)
- Multi-select: false
Store the user's choice or custom input in: SEARCH_QUERY
Step 2: Generate JQL Query
CRITICAL STEP: Invoke the jira-jql skill to translate the natural language query into JQL.
User's query: {SEARCH_QUERY}
Your task as Claude:
- Read and apply the translation patterns from the
jira-jqlskill - Apply fuzzy status matching (e.g., "open" → status IN (Open, 'To Do', 'In Progress', New, Blocked))
- Use smart release pattern (e.g., "release-3.2" → (fixVersion = 'release-3.2' OR labels = 'release-3.2'))
- Handle linkedIssues() for link queries (e.g., "linked to KEY" → issue IN linkedIssues(KEY))
- Include project filters when mentioned for better performance
- Add appropriate ORDER BY clause based on query intent:
- Priority queries:
ORDER BY priority DESC - Recent activity:
ORDER BY updated DESC - Due dates:
ORDER BY due ASC - Sprint:
ORDER BY rank ASC
- Priority queries:
- Quote multi-word values (e.g.,
status = 'In Progress') - Generate syntactically correct, performant JQL
Store the generated JQL in: JQL_QUERY
Example transformations:
- "my open bugs" →
issuetype = Bug AND assignee = currentUser() AND status IN (Open, 'To Do', 'In Progress', New, Blocked) ORDER BY priority DESC - "features in release-3.2" →
issuetype IN (Feature, Story) AND (fixVersion = 'release-3.2' OR labels = 'release-3.2') ORDER BY priority DESC - "linked to RHAISTRAT-123" →
issue IN linkedIssues(RHAISTRAT-123) ORDER BY type ASC
Step 3: Show Generated JQL to User
Display the generated JQL with explanation:
🔍 Generated JQL Query:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
{JQL_QUERY}
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📋 This query will search for:
{brief 1-sentence explanation of what the query does}
Then ask the user to confirm:
Use AskUserQuestion:
Question: Would you like to execute this search?
- Header: "Confirm Search"
- Options:
- Label: "Execute this search (Recommended)" Description: "Run the query and show results"
- Label: "Modify the JQL manually" Description: "Edit the query before running"
- Label: "Cancel" Description: "Don't run the search"
- Multi-select: false
Based on user's choice:
If "Execute this search":
- Proceed to Step 4 with
JQL_QUERY
If "Modify the JQL manually":
- Ask the user: "Please provide the modified JQL query:"
- Use "Other" option to get custom JQL input
- Store in
JQL_QUERY - Show the modified query again for confirmation
- Proceed to Step 4
If "Cancel":
- Stop and display: "Search cancelled. Use
/jira:searchto try again." - Exit
Step 4: Execute JQL Query
Execute the search using the Python client:
"$PLUGIN_ROOT/scripts/run.sh" jira_client.py search_issues "$JQL_QUERY"
Notes:
- The
search_issuesoperation returns formatted output (table or list) - Uses fresh results (no cache) for up-to-date search
- Handles empty results gracefully
- Includes helpful footer with quick actions
Step 5: Display Results
The Python script returns pre-formatted results. Display them directly to the user.
The output includes:
- Issue count
- Formatted table (terminals ≥120 chars) or list (narrow terminals)
- Summary footer
- Quick action suggestions
If no results: The Python script handles this and suggests alternatives.
After displaying results:
Show helpful next steps:
💡 What's next?
- Use /jira:summarize <KEY> for detailed issue info
- Use /jira:analyze <KEY> to analyze with code context
- Use /jira:update <KEY> to modify an issue
- Use /jira:search for a new search
Translation Examples
Here are examples of how natural language queries are translated to JQL:
Example 1: "my open bugs"
issuetype = Bug
AND assignee = currentUser()
AND status IN (Open, 'To Do', 'In Progress', New, Blocked)
ORDER BY priority DESC, updated DESC
Example 2: "features targeted to release-3.2 that are still open"
issuetype IN (Feature, Story, 'User Story')
AND (fixVersion = 'release-3.2' OR labels = 'release-3.2')
AND status NOT IN (Done, Closed, Resolved, 'Refinement Complete')
ORDER BY priority DESC
Example 3: "bugs in RHAIENG assigned to the QA team"
project = RHAIENG
AND issuetype = Bug
AND (assignee IN membersOf("qa") OR assignee IN membersOf("quality-assurance"))
ORDER BY priority DESC
Example 4: "issues linked to RHAISTRAT-123"
issue IN linkedIssues(RHAISTRAT-123)
ORDER BY type ASC, key ASC
Example 5: "my issues updated in the last week"
assignee = currentUser()
AND updated >= -7d
ORDER BY updated DESC
Example 6: "unassigned high priority bugs in RHAIENG"
project = RHAIENG
AND issuetype = Bug
AND priority IN (Highest, High, Critical)
AND assignee IS EMPTY
ORDER BY priority DESC, created DESC
Example 7: "issues in the current sprint"
sprint IN openSprints()
ORDER BY rank ASC
Example 8: "my overdue tasks"
assignee = currentUser()
AND due < now()
AND resolution = Unresolved
ORDER BY due ASC
Smart Features
Fuzzy Status Matching
The search understands common status terms and maps them intelligently:
| User Says | Translates To |
|---|---|
| "open" / "active" / "not done" | status IN (Open, 'To Do', 'In Progress', 'Refinement In Progress', New, Blocked) |
| "closed" / "done" / "finished" | status IN (Closed, Done, Resolved, 'Refinement Complete') |
| "in progress" / "working on" | status IN ('In Progress', 'Code Review', Testing, 'Refinement In Progress') |
| "blocked" / "stuck" | status IN (Blocked, Waiting, 'Pending Review') |
Release/Version Queries
Automatically checks both fixVersion field AND labels (teams use inconsistently):
"release-3.2" → (fixVersion = 'release-3.2' OR labels = 'release-3.2')
"version 2.5" → (fixVersion = '2.5' OR labels = '2.5')
Link Following
Handles linked issues and specific link types:
"linked to RHAI-123" → issue IN linkedIssues(RHAI-123)
"blocks RHAI-456" → issue IN linkedIssues(RHAI-456, "blocks")
"blocked by RHAI-789" → issue IN linkedIssues(RHAI-789, "is blocked by")
Ownership Recognition
"my issues" → assignee = currentUser()
"created by me" → reporter = currentUser()
"unassigned" → assignee IS EMPTY
"assigned to john" → assignee = john
Time Period Understanding
"last week" → updated >= -7d
"yesterday" → updated >= -1d
"last month" → updated >= -30d
"today" → updated >= startOfDay()
"this month" → created >= startOfMonth()
Priority Intelligence
"high priority" / "urgent" / "critical" → priority IN (Highest, High, Critical)
"low priority" → priority IN (Lowest, Low)
Error Handling
Invalid Project Name
Query: "bugs in INVALIDPROJ" Result: Empty results with helpful message:
✨ No issues found matching your search.
Try:
- Broadening your search criteria
- Checking project names and field values
- Using /jira:my-issues for your assigned issues
Ambiguous Query
Query: "issues"
Strategy: Default to user's open issues
JQL: assignee = currentUser() AND resolution = Unresolved ORDER BY updated DESC
JQL Syntax Error
Prevention: The jira-jql skill prevents most syntax errors Backup: User sees JQL before execution and can modify Final: Python shows API error message if still invalid
Performance Tips
The generated JQL is optimized for performance:
- Project filters included: When a project is mentioned, it's always included first (10-100x speedup)
- Indexed fields preferred: Uses status, priority, assignee (fast) over text searches (slow)
- Sensible ordering: Results are pre-sorted by relevance (priority, recency, etc.)
- Fresh results: Uses no cache for up-to-date search results
Integration with Other Commands
After searching, you can:
- View details:
/jira:summarize <ISSUE-KEY> - Analyze with code:
/jira:analyze <ISSUE-KEY> - Update issue:
/jira:update <ISSUE-KEY> - Check sprint:
/jira:sprint(if issues are in a sprint)
Tips for Better Searches
- Include project name for faster results: "bugs in RHAIENG" vs just "bugs"
- Be specific about status: "open bugs" vs "bugs"
- Mention time frames: "updated last week" for recent activity
- Use ownership: "my bugs" vs "bugs" to narrow scope
- Combine criteria: "my high priority bugs in RHAIENG updated this week"
Troubleshooting
Issue: No results found
- Check project name spelling (case-sensitive)
- Try broadening criteria (remove filters)
- Use
/jira:my-issuesto see if there are any issues assigned to you
Issue: Too many results
- Add project filter: "bugs in PROJECT"
- Add status filter: "open bugs"
- Add time filter: "updated last month"
- Add priority filter: "high priority bugs"
Issue: JQL syntax error
- Review generated JQL in Step 3
- Select "Modify the JQL manually" to fix
- Check for missing quotes around multi-word values
- Consult
skills/jira-jql/SKILL.mdfor syntax reference
Issue: Unexpected results
- Review the generated JQL to understand what was searched
- Fuzzy matching may have included more statuses than expected
- Modify the JQL manually for exact matching
Technical Details
Caching
- Search results are NOT cached (always fresh data)
- Use
/jira:my-issuesfor cached issue lists (faster, less API load)
Output Format
- Table format: Terminals ≥120 characters wide
- List format: Narrow terminals or if preferred
- Auto-detects terminal width
JQL Character Limits
- JIRA Cloud: 8000 characters max per JQL query
- Most generated queries: <500 characters
- Complex queries with many conditions may approach limit
Related Commands
/jira:my-issues- Quick view of your assigned issues/jira:sprint- View all issues in a sprint/jira:summarize- Detailed view of a single issue/jira:analyze- Analyze issue with code context/jira:update- Update issue fields
References
This command uses:
skills/jira-jql/SKILL.md- JQL translation knowledge and patternsscripts/jira_client.py- JIRA API client with search_issues operation- Atlassian JQL Documentation: https://support.atlassian.com/jira-software-cloud/docs/use-advanced-search-with-jira-query-language-jql/
For advanced JQL queries and syntax, consult the jira-jql skill or Atlassian documentation.
/jira:setup - Configure JIRA Credentials and Settings
Interactive configuration wizard for jira plugin.
Task
Set up JIRA connection credentials and default settings for the jira plugin.
Step 0: Resolve Plugin Root
Extract PLUGIN_ROOT from the <jira-context> system reminder
injected by the UserPromptSubmit hook. Use the value from <plugin-root>.
Then invoke the setup-plugin-env skill to ensure the venv is ready.
Step 1: Check for Existing Configuration
Check if configuration already exists:
CONFIG_FILE="$HOME/.claude/jira.local.md"
if [ -f "$CONFIG_FILE" ]; then
echo "📋 Found existing configuration at $CONFIG_FILE"
# Check if --reset flag was provided
if [[ "$*" == *"--reset"* ]]; then
echo "🔄 Resetting configuration..."
else
echo ""
echo "Configuration already exists. Options:"
echo "1. Keep existing configuration"
echo "2. Update specific settings"
echo "3. Reset all settings"
echo ""
# Continue to interactive wizard
fi
else
echo "📝 No existing configuration found. Starting setup wizard..."
fi
Step 2: Interactive Configuration Wizard
Use AskUserQuestion to gather configuration values:
Question 1: JIRA Server URL
- Header: "JIRA Server"
- Question: "What is your JIRA server URL?"
- Options:
- Label: "Red Hat JIRA (issues.redhat.com)" Description: "Use https://issues.redhat.com"
- Label: "Custom URL" Description: "Enter a different JIRA server URL"
- Store answer in:
jira_url
Question 2: Authentication Token
- Header: "API Token"
- Question: "Enter your JIRA Personal Access Token (PAT)"
- Note: This will be asked via "Other" text input since it's sensitive
- Guidance: "Create a PAT in JIRA under Profile → Personal Access Tokens"
- Store answer in:
jira_pat
Question 3: Default Username
- Header: "Username"
- Question: "What is your JIRA username?"
- Options:
- Label: "Auto-detect from API" Description: "Query JIRA API after connection test"
- Label: "Enter manually" Description: "Specify username now"
- Store answer in:
default_username
Question 4: Default Project
- Header: "Project"
- Question: "Which JIRA project do you primarily work with?"
- Options:
- Label: "RHAISTRAT" Description: "Red Hat AI Strategic Features"
- Label: "RHOAISTRAT" Description: "Red Hat OpenShift AI Strategic Features"
- Label: "RHAIENG" Description: "Red Hat AI Engineering"
- Label: "Other" Description: "Enter project key manually"
- Store answer in:
default_project
Question 5: Current Sprint (optional)
- Header: "Sprint"
- Question: "What is your current sprint ID or name? (optional)"
- Note: Can be left blank and set later
- Store answer in:
current_sprint_id
Step 4: Test Connection
Before saving, test the JIRA connection:
VENV_PYTHON=".claude/jira/venv/bin/python"
echo ""
echo "🔍 Testing JIRA connection..."
# Create temporary config for testing
TEMP_CONFIG=$(mktemp)
cat > "$TEMP_CONFIG" << EOF
---
jira_url: "$jira_url"
jira_pat: "$jira_pat"
---
EOF
# Set environment variables for test
export JIRA_URL="$jira_url"
export JIRA_API_TOKEN="$jira_pat"
# Test connection
TEST_RESULT=$("$VENV_PYTHON" "$PLUGIN_ROOT/scripts/jira_client.py" test_connection 2>&1)
if echo "$TEST_RESULT" | grep -q '"success": true'; then
echo "✅ Connection successful!"
# Extract username if auto-detect selected
if [ "$default_username" == "Auto-detect from API" ] || [ -z "$default_username" ]; then
default_username=$(echo "$TEST_RESULT" | grep -o '"user": "[^"]*"' | cut -d'"' -f4)
echo " Detected username: $default_username"
fi
else
echo "❌ Connection failed!"
echo ""
echo "Error details:"
echo "$TEST_RESULT"
echo ""
echo "Please verify your credentials and try again."
exit 1
fi
# Clean up temp config
rm -f "$TEMP_CONFIG"
Step 5: Save Configuration
Create or update .claude/jira.local.md with YAML frontmatter:
CONFIG_FILE="$HOME/.claude/jira.local.md"
CONFIG_DIR="$(dirname "$CONFIG_FILE")"
# Ensure .claude directory exists
mkdir -p "$CONFIG_DIR"
# Create configuration file
cat > "$CONFIG_FILE" << EOF
---
jira_url: "$jira_url"
jira_pat: "$jira_pat"
default_username: "$default_username"
default_project: "$default_project"
current_sprint_id: "$current_sprint_id"
cache_duration: 14400
default_jql_filters: "assignee = currentUser() AND resolution = Unresolved ORDER BY priority DESC"
project_repo_mappings: {}
---
# jira Plugin Configuration
This file stores your JIRA connection settings and preferences for the jira plugin.
## Credentials
- **JIRA URL:** $jira_url
- **Username:** $default_username
## Defaults
- **Project:** $default_project
- **Sprint:** ${current_sprint_id:-"(not set)"}
## Cache Settings
- **Duration:** 14400 seconds (4 hours)
## Repository Mappings
Use \`/jira:repo-add\`, \`/jira:repo-remove\`, and \`/jira:repo-list\` to manage project→repository mappings for code analysis.
## Security Note
This file contains your Personal Access Token. Keep it secure:
- Do not commit to version control
- Do not share with others
- Rotate tokens regularly
EOF
chmod 600 "$CONFIG_FILE"
echo ""
echo "✅ Configuration saved to $CONFIG_FILE"
echo " (File permissions set to 600 for security)"
Step 6: Display Summary
Show configuration summary:
echo ""
echo "📊 Configuration Summary"
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo "JIRA Server: $jira_url"
echo "Username: $default_username"
echo "Default Project: $default_project"
echo "Current Sprint: ${current_sprint_id:-(not set)}"
echo "Cache Duration: 14400 seconds (4 hours)"
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo ""
echo "✨ Setup complete! You can now use jira commands:"
echo ""
echo " /jira:my-issues - List your assigned issues"
echo " /jira:sprint - List issues in current sprint"
echo " /jira:summarize KEY - Summarize a JIRA issue"
echo ""
echo "To update settings later, run: /jira:setup --reset"
echo ""
Step 7: Environment Variable Alternative (Optional)
Inform user about environment variable option:
echo "💡 Alternative: Environment Variables"
echo ""
echo "Instead of storing credentials in the config file, you can use environment variables:"
echo ""
echo " export JIRA_URL=\"$jira_url\""
echo " export JIRA_API_TOKEN=\"your-token-here\""
echo " export JIRA_AUTH_TYPE=\"bearer\""
echo ""
echo "Environment variables override config file settings."
echo ""
Error Handling
If connection test fails:
- Display clear error message
- Suggest common issues:
- Invalid PAT (check token is active)
- Incorrect URL (verify server address)
- Network issues (check connectivity)
- Insufficient permissions (verify token has required scopes)
- Do not save configuration
- Offer to retry
If file write fails:
- Check directory permissions
- Suggest manual creation of
.claude/directory - Display configuration values for manual entry
If --reset flag is provided:
- Confirm with user before deleting existing config
- Back up existing config to
.claude/jira.local.md.bak
Notes
- Personal Access Token is stored in YAML frontmatter (keep file secure)
- File permissions are set to 600 (owner read/write only)
- Configuration can be updated anytime by running
/jira:setupagain - Repository mappings are initially empty (use
/jira:repo-addto configure)
Security Best Practices
- Never commit
.claude/jira.local.mdto version control - Rotate tokens regularly (every 90 days recommended)
- Use minimal permissions for PAT (only what's needed)
- Revoke unused tokens in JIRA settings
- Monitor token usage in JIRA audit logs
/jira:sprint - Sprint Issue Management
Display all issues in the current sprint or a specific sprint with optional grouping and formatting.
Task
Step 0: Resolve Plugin Root
Extract PLUGIN_ROOT from the <jira-context> system reminder
injected by the UserPromptSubmit hook. Use the value from <plugin-root>.
Check <jira-configured> - if false, instruct user to run /jira:setup.
Then invoke the setup-plugin-env skill to ensure the venv is ready.
Step 1: List sprint issues
Execute the sprint query with Python:
"$PLUGIN_ROOT/scripts/run.sh" jira_client.py sprint_issues "$@"
The Python script will:
- Use provided sprint ID or fall back to
current_sprint_idfrom config - Query JIRA for issues in the sprint
- Format output as table or list (based on
--formatflag) - Optionally group by epic (if
--group-by-epicflag is set) - Show sprint progress metrics
Output Format
Table Format (Default)
Similar to /jira:my-issues, displays:
- Issue key, Status, Priority, Summary
- Reporter, Assignee, Epic, Story Points
- Progress indicators
List Format
Numbered list with:
- Issue key and summary
- Status and assignee
- Story points
Grouped by Epic
When --group-by-epic is used:
- Issues organized under their parent epic
- Sub-totals for each epic
- Unassigned issues in separate section
Usage Examples
Current Sprint (from config)
/jira:sprint
Specific Sprint
/jira:sprint 12345
List Format
/jira:sprint --format list
Group by Epic
/jira:sprint --group-by-epic
Filter by Project
/jira:sprint --project RHAISTRAT
Combined
/jira:sprint 12345 --format list --group-by-epic --project RHAISTRAT
Sprint Progress
The output includes sprint progress metrics:
- Total issues: Count of all issues in sprint
- Completed: Issues in "Done" status
- In Progress: Issues being actively worked
- To Do: Issues not yet started
- Story points: Completed vs total
Example:
Sprint Progress:
Total: 15 issues (55 points)
Done: 8 issues (30 points) - 55%
In Progress: 4 issues (15 points)
To Do: 3 issues (10 points)
Configuration
To set your default sprint ID, update ~/.claude/jira.local.md:
---
current_sprint_id: "12345"
---
Then you can just run /jira:sprint without specifying the ID.
Advanced Features
Custom JQL Filter
You can define a custom sprint JQL in your config:
---
default_sprint_jql: "Sprint = 12345 AND status != Closed ORDER BY epic ASC, priority DESC"
---
Epic Grouping
When --group-by-epic is used, issues are displayed like:
Epic: RHAISTRAT-100 - Authentication Improvements
├─ RHAISTRAT-101 [In Progress] Add OAuth2 support
├─ RHAISTRAT-102 [Done] Update login UI
└─ RHAISTRAT-103 [To Do] Add MFA
Subtotal: 3 issues, 13 points (1 done)
Epic: RHAISTRAT-200 - Performance Optimization
├─ RHAISTRAT-201 [Done] Database query optimization
└─ RHAISTRAT-202 [In Progress] Cache implementation
Subtotal: 2 issues, 8 points (1 done)
No Epic:
├─ RHAISTRAT-301 [To Do] Fix deployment script
Subtotal: 1 issue, 3 points (0 done)
Error Handling
If sprint ID not configured:
❌ No sprint ID provided and no current_sprint_id in config
Please specify a sprint ID or configure current_sprint_id in ~/.claude/jira.local.md
If sprint not found:
❌ Sprint 12345 not found
Please check the sprint ID and try again.
If no issues in sprint:
✓ Sprint 12345 found but contains no issues
The sprint may be empty or you may not have permission to view issues.
Tips
- Set default sprint: Configure
current_sprint_idin your config for quick access - Epic planning: Use
--group-by-epicto see epic progress at a glance - Quick status: Run without flags for a quick sprint overview
- Story points: Ensure your JIRA instance has story points field configured
Integration
This command integrates with:
- scripts/jira_client.py - Executes sprint_issues operation
- .claude/jira.local.md - Reads current_sprint_id configuration
- skills/jira-integration.md - Uses sprint field mappings
/jira:summarize - Summarize JIRA Issue
Fetch and display a concise, readable summary of a JIRA issue.
Task
Step 0: Resolve Plugin Root
Extract PLUGIN_ROOT from the <jira-context> system reminder
injected by the UserPromptSubmit hook. Use the value from <plugin-root>.
Check <jira-configured> - if false, instruct user to run /jira:setup.
Then invoke the setup-plugin-env skill to ensure the venv is ready.
Step 1: Summarize JIRA issue
"$PLUGIN_ROOT/scripts/run.sh" jira_client.py summarize_issue "$@"
Usage Examples
Basic Summary
/jira:summarize RHAISTRAT-123
Fresh Data (Bypass Cache)
/jira:summarize RHAISTRAT-123 --no-cache
Output Format
The summary includes:
Header:
- Issue key and summary title
Metadata:
- Type (e.g., Epic, Story, Bug)
- Status (e.g., In Progress, Closed)
- Priority (e.g., High, Medium, Low)
People:
- Reporter
- Assignee
Description:
- Full issue description
Labels:
- Associated labels (if any)
Versions:
- Fix versions (if any)
Components:
- Related components (if any)
Linked Issues:
- Related, blocks, or blocked-by issues
Recent Comments:
- Last 3 comments on the issue
URL:
- Direct link to the JIRA issue
Error Handling
If issue key is invalid:
❌ Invalid issue key format: INVALID
Expected format: PROJECT-123
If issue not found or unauthorized:
❌ Failed to fetch issue RHAISTRAT-123:
Issue does not exist or you do not have permission to see it
Make sure:
- Issue key is correct
- You have permission to view this issue
- JIRA connection is configured (/jira:setup)
If JIRA not configured:
❌ JIRA not configured. Please run /jira:setup first.
Performance Notes
- Issue data is cached for 4 hours by default
- Use
--no-cacheto fetch fresh data - Cache location:
/tmp/jira-cache/ - Clear all cache:
rm -rf /tmp/jira-cache/
Tips
- Copy issue key: Issue keys are shown in
/jira:my-issuesoutput - Fresh data: Use
--no-cachewhen you know the issue was just updated - Click links: The JIRA URL in the output is clickable in modern terminals
- Pipe to file: Save summary for reference:
/jira:summarize KEY > summary.txt
Integration
This command integrates with:
- scripts/jira_client.py - Executes summarize_issue operation
- .claude/jira.local.md - Reads JIRA credentials and configuration
- skills/jira-integration.md - Uses field mappings and formatting patterns
/jira:update - Update JIRA Issue
Interactively update a JIRA issue with comments, status changes, assignee updates, and more.
Task
Step 0: Resolve Plugin Root
Extract PLUGIN_ROOT from the <jira-context> system reminder
injected by the UserPromptSubmit hook. Use the value from <plugin-root>.
Check <jira-configured> - if false, instruct user to run /jira:setup.
Then invoke the setup-plugin-env skill to ensure the venv is ready.
Step 1: Determine update mode
Check if shortcut flags were provided:
Shortcut mode (flags provided):
--comment "text"- Add comment--status "status"- Change status--assignee "user"- Change assignee
Interactive mode (no flags):
- Use AskUserQuestion to select what to update
Step 2a: Shortcut Mode - Direct update
If flags are provided, execute the update directly:
"$PLUGIN_ROOT/scripts/run.sh" jira_client.py update_issue "$@"
Step 2b: Interactive Mode - Ask user
If no flags provided, ask the user what they want to update:
Question: What would you like to update?
- Header: "Update Type"
- Options:
- Label: "Add a comment" Description: "Add a comment to the issue"
- Label: "Change status/transition" Description: "Move issue to a different status"
- Label: "Change assignee" Description: "Assign issue to someone else"
- Label: "Multiple updates" Description: "Make several changes at once"
- Multi-select: false
Based on the user's choice:
If "Add a comment":
- Ask for comment text (via "Other" option)
- Call:
"$PLUGIN_ROOT/scripts/run.sh" jira_client.py update_issue "$ISSUE_KEY" --comment "$COMMENT"
If "Change status/transition":
- First fetch available transitions:
"$PLUGIN_ROOT/scripts/run.sh" jira_client.py get_transitions "$ISSUE_KEY" - Show user available transitions and ask them to choose
- Call:
"$PLUGIN_ROOT/scripts/run.sh" jira_client.py update_issue "$ISSUE_KEY" --status "$STATUS"
If "Change assignee":
- Ask for assignee username (via "Other" option)
- Call:
"$PLUGIN_ROOT/scripts/run.sh" jira_client.py update_issue "$ISSUE_KEY" --assignee "$ASSIGNEE"
If "Multiple updates":
- Ask about each type of update sequentially
- Collect all changes
- Call:
"$PLUGIN_ROOT/scripts/run.sh" jira_client.py update_issue "$ISSUE_KEY" --comment "$COMMENT" --status "$STATUS" --assignee "$ASSIGNEE"
Step 3: Preview and confirm
CRITICAL: Before making any changes, show the user:
- Issue key and current state
- Proposed changes
- Ask for confirmation
Question: Confirm changes?
- Header: "Confirm"
- Options:
- Label: "Yes, update the issue (Recommended)" Description: "Apply the changes to JIRA"
- Label: "No, cancel" Description: "Don't make any changes"
Only proceed if user confirms "Yes".
Step 4: Execute update
Execute the update with the collected parameters.
Display the result to the user with:
- Success/failure status
- Updated fields
- Link to the issue
Usage Examples
Add a Comment
/jira:update RHAISTRAT-123 --comment "Completed initial implementation"
Change Status
/jira:update RHAISTRAT-123 --status "In Progress"
Change Assignee
/jira:update RHAISTRAT-123 --assignee john.doe
Interactive Mode
/jira:update RHAISTRAT-123
# Will prompt for what to update
Multiple Updates
/jira:update RHAISTRAT-123 --comment "Moving to review" --status "Code Review"
Important Notes
- Always ask for confirmation before making changes
- Show preview of what will change
- Validate issue exists before attempting update
- Error handling for failed transitions or invalid assignees
- Cache invalidation after successful update
Error Handling
If issue doesn't exist:
❌ Issue RHAISTRAT-123 not found
Please check the issue key and try again.
If transition is invalid:
❌ Cannot transition to "In Progress"
Available transitions: To Do, Done, Blocked
If assignee is invalid:
❌ User "invalid.user" not found
Please check the username and try again.
Integration
This command integrates with:
- scripts/jira_client.py - Executes update_issue, get_transitions operations
- .claude/jira.local.md - Reads JIRA credentials
- AskUserQuestion - Interactive mode for user input
Hooks 1
Sponsors
Details
- Marketplace
- rhuss/cc-jira
- Source
- jira
- Author
- Red Hat AI Team
- Category
- Integration
- License
- MIT