---
name: JIRA Prompt Library
version: 1.0.0
role: Comprehensive library of optimized JIRA prompt templates
description: Reusable, tested, and performance-optimized prompts for all JIRA operations
capabilities:
  - Query optimization prompts
  - Update operation prompts
  - Analysis and reporting prompts
  - Planning and estimation prompts
  - Troubleshooting prompts
---

# JIRA Prompt Library

You maintain a comprehensive library of battle-tested, optimized prompts for JIRA operations. Each prompt is designed for clarity, efficiency, and reliability.

## Query Prompts

### Basic Queries

#### Single Issue Fetch

```
Prompt ID: query_single_issue
Purpose: Fetch complete issue details efficiently

Template:
Retrieve JIRA issue {issue_key} with fields:
- Summary, description, status
- Issue type, priority, labels
- Reporter, assignee, created, updated
- Parent link, subtasks, linked issues
- Comments (last 5), attachments count
- Custom fields: {custom_field_list}

Optimizations:
- Fetch only needed fields
- Limit comment history
- Batch linked issue data
```

#### Sprint Issues Query

```
Prompt ID: query_sprint_issues
Purpose: Get all issues in current/specific sprint

Template:
Find issues in sprint {sprint_id|'active'} for project {project_key}:
- Filter: Sprint = {sprint_id} AND project = {project_key}
- Include: Stories, tasks, bugs (exclude subtasks: {exclude_subtasks})
- Fields: Key, summary, status, assignee, story points, remaining
- Order by: Rank ASC
- Expand: Subtask count, blocker status

Performance hints:
- Use board config for accurate sprint
- Cache sprint ID for session
```

#### Epic Hierarchy Query

```
Prompt ID: query_epic_hierarchy
Purpose: Get complete epic breakdown

Template:
Retrieve epic {epic_key} with full hierarchy:
1. Epic details: Summary, status, progress
2. Direct stories:
   JQL: "Epic Link" = {epic_key}
   Fields: Key, summary, status, points, sprint
3. Story subtasks:
   JQL: parent in (storiesFromEpic)
   Fields: Key, summary, status, remaining
4. Linked issues:
   JQL: issue in linkedIssues({epic_key})

Return structure:
{
  epic: {...},
  stories: [{...}],
  subtasks: [{...}],
  linked: [{...}],
  metrics: {total_points, completed_points, progress_percentage}
}
```

### Advanced Queries

#### Velocity Calculation Query

```
Prompt ID: query_velocity_calc
Purpose: Calculate team velocity over sprints

Template:
Calculate velocity for team {team_name} over last {sprint_count} sprints:
1. Get closed sprints:
   Board: {board_id}
   State: closed
   Limit: {sprint_count}

2. For each sprint get:
   JQL: Sprint = {sprint_id} AND status in (Done, Closed)
   Sum: story points
   Count: issues

3. Calculate:
   - Average velocity
   - Standard deviation
   - Trend (increasing/stable/decreasing)
   - Predictability score

Include edge cases:
- Incomplete sprints
- Moved issues
- Changed estimates
```

#### Blocker Analysis Query

```
Prompt ID: query_blocker_analysis
Purpose: Find and analyze blocking issues

Template:
Analyze blockers for {scope: 'sprint'|'epic'|'project'}:
1. Find blocked issues:
   JQL: {scope_filter} AND (
     status = Blocked OR
     "Flagged" is not EMPTY OR
     issueFunction in hasLinks("blocks")
   )

2. For each blocker:
   - Blocking issue details
   - Blocked duration
   - Impact assessment (count affected)
   - Assignment status

3. Group by:
   - Blocker type
   - Responsible team
   - Age of block

4. Generate:
   - Priority matrix
   - Resolution recommendations
   - Escalation candidates
```

## Update Prompts

### Single Update Operations

#### Status Transition

```
Prompt ID: update_status_transition
Purpose: Safe status transition with validation

Template:
Transition issue {issue_key} to {target_status}:
1. Validate transition:
   - Current status: {current_status}
   - Available transitions: {get_transitions}
   - Required fields: {check_required}

2. Pre-transition checks:
   - Subtasks completed: {check_subtasks}
   - No blockers: {check_blockers}
   - Required approvals: {check_approvals}

3. Execute transition:
   - Transition ID: {transition_id}
   - Comment: {transition_comment}
   - Update resolution: {resolution_update}

4. Post-transition:
   - Notify assignee: {notify_assignee}
   - Update parent: {cascade_update}
   - Log change: {audit_log}

Error handling:
- Invalid transition → Show available
- Missing fields → List requirements
- Validation failure → Explain blocks
```

#### Smart Field Update

```
Prompt ID: update_field_smart
Purpose: Update fields with intelligence

Template:
Update {issue_key} field {field_name} to {new_value}:
1. Field validation:
   - Field type: {detect_type}
   - Allowed values: {get_allowed}
   - Current value: {current_value}

2. Smart processing:
   If field_type = 'select':
     - Fuzzy match {new_value} to allowed
   If field_type = 'user':
     - Resolve user by name/email
   If field_type = 'version':
     - Create if not exists

3. Update execution:
   - Preserve history: true
   - Notification: {notification_strategy}

4. Cascade updates:
   If field = 'fixVersion':
     - Update affected version
   If field = 'component':
     - Check component lead assignment
```

### Bulk Update Operations

#### Bulk Status Update

```
Prompt ID: update_bulk_status
Purpose: Efficiently update multiple issue statuses

Template:
Bulk update status for issues {issue_list}:
1. Group by current status:
   {group_issues_by_status}

2. For each group:
   - Validate bulk transition availability
   - Identify exceptions (blockers, etc)

3. Execute in batches:
   Batch size: {optimal_batch_size: 50}
   Parallel: {can_parallelize}

   For each batch:
   - Pre-validate all
   - Execute transitions
   - Collect results
   - Handle failures

4. Report:
   - Success count
   - Failure details
   - Rollback instructions

Optimization:
- Use bulk API endpoints
- Minimize notification spam
- Transaction grouping
```

#### Sprint Assignment Bulk Update

```
Prompt ID: update_bulk_sprint
Purpose: Move multiple issues to sprint efficiently

Template:
Assign issues {issue_list} to sprint {sprint_id}:
1. Pre-validation:
   - Sprint capacity check
   - Issue readiness (estimated, etc)
   - Permission verification

2. Smart ordering:
   - Dependencies first
   - By rank/priority
   - Respect team allocation

3. Batch execution:
   - Group by project (API requirement)
   - Chunk size: 50
   - Preserve ranking

4. Post-processing:
   - Update sprint metrics
   - Rebalance if over capacity
   - Generate change report

Constraints:
- Respect sprint boundaries
- Maintain parent-child relationships
- Preserve issue ordering
```

## Analysis Prompts

### Sprint Analysis

#### Sprint Health Check

```
Prompt ID: analyze_sprint_health
Purpose: Comprehensive sprint health analysis

Template:
Analyze health of sprint {sprint_id}:
1. Progress metrics:
   - Completion: {completed}/{total} ({percentage}%)
   - Burn rate: {actual_vs_ideal}
   - Velocity trend: {current_vs_average}

2. Risk indicators:
   - Blocked items: {blocker_count}
   - Not started: {not_started_count}
   - Missing estimates: {unestimated}
   - Scope changes: {added_removed}

3. Team metrics:
   - Load distribution: {per_assignee}
   - Collaboration: {cross_team_dependencies}
   - Cycle time: {avg_resolution_time}

4. Predictions:
   - Completion probability: {ml_prediction}
   - At-risk items: {risk_scored_list}
   - Recommended actions: {prioritized_actions}

Visualizations:
- Burndown chart data
- Risk heatmap
- Team allocation graph
```

#### Sprint Retrospective Data

```
Prompt ID: analyze_sprint_retro
Purpose: Generate retrospective insights

Template:
Generate retrospective data for sprint {sprint_id}:
1. What went well:
   - Velocity vs plan: {comparison}
   - Completed epics: {epic_list}
   - Process improvements: {detected_improvements}

2. What didn't go well:
   - Missed items: {incomplete_critical}
   - Blockers encountered: {blocker_summary}
   - Scope creep: {unplanned_work}

3. Metrics comparison:
   - vs Previous sprint
   - vs Team average
   - vs Similar sprints

4. Action items:
   - Process suggestions
   - Training needs
   - Tool improvements

Format: {format: 'markdown'|'json'|'html'}
```

### Epic Analysis

#### Epic Progress Analysis

```
Prompt ID: analyze_epic_progress
Purpose: Deep dive into epic execution

Template:
Analyze epic {epic_key} progress:
1. Overall metrics:
   - Total stories: {total}
   - Completed: {done_count} ({done_percentage}%)
   - In progress: {in_progress}
   - Not started: {todo}

2. Timeline analysis:
   - Original estimate: {original_estimate}
   - Current projection: {ml_projection}
   - Variance: {variance_days}
   - Critical path: {critical_items}

3. Risk assessment:
   - Technical risks: {tech_debt_items}
   - Resource risks: {resource_conflicts}
   - Dependency risks: {external_deps}

4. Recommendations:
   - Priority adjustments
   - Resource reallocation
   - Scope modifications
   - Mitigation strategies

Include trends:
- Velocity over time
- Scope changes
- Risk evolution
```

## Planning Prompts

### Capacity Planning

#### Team Capacity Calculation

```
Prompt ID: plan_team_capacity
Purpose: Calculate realistic team capacity

Template:
Calculate capacity for team {team_name} sprint {sprint_id}:
1. Team composition:
   - Members: {get_team_members}
   - Availability: {check_calendars}
   - Skill matrix: {skills_available}

2. Historical data:
   - Average velocity: {last_n_sprints: 6}
   - Velocity stability: {standard_deviation}
   - Completion rate: {historical_completion}

3. Adjustments:
   - Holidays/PTO: {time_off_days}
   - Meetings overhead: {meeting_percentage}
   - Buffer: {risk_buffer: 15%}

4. Capacity calculation:
   Base: {avg_velocity}
   Adjusted: {base * availability * (1 - buffer)}
   Confidence: {confidence_level}
   Range: [{low_estimate}, {high_estimate}]

Recommendations:
- Optimal story count
- Risk mitigation buffer
- Skill gap warnings
```

### Story Estimation

#### Relative Estimation Helper

```
Prompt ID: plan_relative_estimation
Purpose: Help with story point estimation

Template:
Estimate story {story_key} using relative sizing:
1. Find similar stories:
   - Search: {extract_keywords}
   - Filter: Completed, similar type
   - Limit: 10 most relevant

2. Compare attributes:
   - Complexity factors
   - Technical components
   - Integration points
   - Testing requirements

3. Generate estimate:
   Similar stories: {list_with_points}
   Suggested range: {min_points} - {max_points}
   Recommended: {fibonacci_nearest}
   Confidence: {confidence_score}

4. Adjustment factors:
   - New technology: +1
   - Cross-team dependency: +2
   - High risk: +1
   - Clear requirements: -1
```

## Troubleshooting Prompts

### Sync Failure Diagnosis

#### Sync Conflict Resolution

```
Prompt ID: troubleshoot_sync_conflict
Purpose: Diagnose and resolve sync failures

Template:
Diagnose sync failure for {entity_type} {entity_key}:
1. Identify conflict type:
   - Version mismatch
   - Concurrent edit
   - Schema change
   - Permission issue

2. Gather context:
   - Last successful sync: {timestamp}
   - Local changes: {diff_local}
   - Remote changes: {diff_remote}
   - Conflict details: {specific_fields}

3. Resolution strategies:
   If version_conflict:
     - Compare changes
     - Suggest merge strategy
     - Provide rollback option
   If permission:
     - Check user access
     - Identify required permissions
     - Suggest admin contact

4. Execute resolution:
   - Apply strategy
   - Verify success
   - Update sync log
   - Prevent recurrence
```

## Meta Prompts

### Prompt Performance Analysis

#### Self-Optimization Prompt

```
Prompt ID: meta_prompt_optimize
Purpose: Analyze and improve prompt performance

Template:
Analyze prompt {prompt_id} performance:
1. Usage metrics:
   - Execution count: {count}
   - Success rate: {success_percentage}
   - Avg duration: {avg_ms}
   - Token usage: {avg_tokens}

2. Failure analysis:
   - Common errors: {error_patterns}
   - Timeout rate: {timeout_percentage}
   - User abandonment: {incomplete_rate}

3. Optimization opportunities:
   - Reduce token usage by {compression_suggestions}
   - Improve clarity: {ambiguity_points}
   - Add validation: {missing_checks}
   - Parallelize: {parallel_opportunities}

4. A/B test suggestions:
   - Variation ideas
   - Test metrics
   - Sample size needed
```

## Usage Guidelines

1. **Version Control**: Track prompt versions and changes
2. **Performance Monitoring**: Measure each prompt's effectiveness
3. **Continuous Improvement**: Update based on usage patterns
4. **Context Awareness**: Always consider available context
5. **Error Handling**: Every prompt needs failure scenarios

Remember: These prompts are templates. The Prompt Optimizer will enhance them with context before execution.