Jira AI Resolver - VS Code Extension
🔍 Intelligent Root Cause Analysis & Technical Solutions for Jira Issues
Export Jira tickets to AI-friendly markdown format for intelligent bug analysis and automated fix suggestions - directly from Visual Studio Code!
Overview
Jira AI Resolver is a Visual Studio Code extension that transforms your Jira backlog into comprehensive, AI-ready markdown documents. It combines a beautiful VS Code interface with powerful Jira export capabilities to help you resolve bugs 10-20x faster using AI assistance.
🎯 VS Code Extension Features
Intuitive GUI Interface
- Visual File Selection: Browse and select configuration and CSV files with native file dialogs
- Real-time Progress Tracking: Beautiful progress bar showing current ticket being processed
- Live Status Updates: See exactly which ticket is being analyzed in real-time
- Professional UI: Modern, VSCode-themed interface that fits seamlessly in your workflow
- Error Handling: Clear error messages and troubleshooting guidance
One-Click Export
- Open Command Palette (
Ctrl+Shift+P / Cmd+Shift+P)
- Run "Jira AI Resolver: Run Export"
- Select your config file (contains Jira URL and credentials)
- Select your CSV file (exported from Jira with ticket IDs)
- Click "Start Analysis" - sit back and watch the magic happen!
Automatic Output Management
- Creates
jira_exports/ folder in your workspace
- One markdown file per ticket (e.g.,
PROJ-12345.md)
- Option to open folder directly after export
- Files ready for AI analysis immediately
Built-in Features
- ✅ VPN Connectivity Notice: Reminds you to connect to VPN for on-premise Jira
- ✅ Batch Processing: Handle multiple tickets from a CSV export
- ✅ Progress Indicators: Visual feedback with current/total counts
- ✅ Success Notifications: Links to open the export folder when complete
- ✅ Error Recovery: Graceful handling of connection issues and rate limits
Quick Start
VS Code Extension Usage
1. Prepare Your Files
Configuration File (e.g., jira-config.properties):
jira.url=https://your-jira-instance.com
jira.user=your-email@company.com
jira.token=your-personal-access-token
CSV File (exported from Jira):
Issue key
PROJ-12345
PROJ-12346
2. Run the Extension
- Open Command Palette:
Ctrl+Shift+P (Windows/Linux) or Cmd+Shift+P (Mac)
- Type: "Jira AI Resolver" and select "Run Export"
- Browse and select your config file
- Browse and select your CSV file
- Click "Start Analysis"
- Watch the progress bar as tickets are exported!
3. Upload to AI (Claude/Gemini/ChatGPT)
Upload the generated .md file to your AI tool of choice.
3. Get Bug Analysis Document
AI generates a comprehensive analysis with:
- Root cause identification
- Step-by-step fix plan
- Ready-to-use code snippets (BEFORE/AFTER)
- Complete test implementations
- Impact assessment
- Testing strategy
4. Implement the Fix
Copy the code from the Bug Analysis Document and apply to your codebase.
What Makes This Special?
Traditional Approach (Without JiraExporter)
Developer reads Jira ticket
↓
Searches codebase manually
↓
Debugs to find root cause (hours)
↓
Writes fix (trial and error)
↓
Writes tests
↓
Time: 1-3 days
AI-Powered Approach (With JiraExporter)
Run JiraExporter (2 minutes)
↓
Upload to AI (1 minute)
↓
Review Bug Analysis Document (15 minutes)
↓
Apply code changes (30 minutes)
↓
Run provided tests (5 minutes)
↓
Time: ~1 hour
10-20x faster bug resolution!
How It Works
Phase 1: Smart Jira Export
JiraExporter fetches and formats:
- 15+ metadata fields (status, priority, assignee, versions, labels, environment)
- Structured descriptions (auto-detects: Steps to Reproduce, Expected/Actual Behavior, Error Details)
- Complete comment timeline (all discussion with timestamps)
- Linked issues (with relationship context: "blocks", "duplicates", etc.)
- Attachments metadata (files, sizes, types)
- Subtasks (breakdown with status)
Phase 2: AI Analysis
AI receives the optimized markdown and generates a Bug Analysis Document containing:
1. Root Cause Analysis
Root Cause: NullPointerException in FormValidator.sanitizeInput() at line 45
Call Stack:
FormValidator.sanitizeInput() → returns null
UserController.registerUser() → calls .getBytes() on null
Exception thrown
Why: Regex pattern [^A-Za-z0-9 ] strips all Unicode characters,
resulting in empty string, which method converts to null.
2. Fix Plan
Step 1: Update regex to support Unicode
Step 2: Add null safety checks
Step 3: Update configuration for UTF-8
Step 4: Add comprehensive tests
3. Code Changes (BEFORE/AFTER)
// File: src/main/java/com/ybali/web/FormValidator.java
// Lines: 42-46
BEFORE:
public static String sanitizeInput(String input) {
String sanitized = input.replaceAll("[^A-Za-z0-9 ]", "");
return sanitized.isEmpty() ? null : sanitized;
}
AFTER:
public static String sanitizeInput(String input) {
if (input == null) return "";
// Unicode-aware: \p{L}=letters, \p{N}=numbers, \p{M}=accents
String sanitized = input.replaceAll("[^\\p{L}\\p{N}\\p{Z}\\p{M}'-]", "");
return sanitized.trim(); // Never return null
}
4. Complete Test Suite
// Ready-to-use unit tests
@Test
public void testSanitizeInput_WithUnicode() {
assertEquals("José García", FormValidator.sanitizeInput("José García"));
assertEquals("王小明", FormValidator.sanitizeInput("王小明"));
assertEquals("Иван Петров", FormValidator.sanitizeInput("Иван Петров"));
}
5. Impact Assessment
Resolves: SM-12345, SM-12340
Unblocks: SM-12320
Breaking Changes: None
Config Changes: server.xml (UTF-8 encoding)
Features
| Field |
Description |
AI Benefit |
| Status |
Open/In Progress/Closed |
Understand current state |
| Priority |
High/Medium/Low |
Assess urgency |
| Issue Type |
Bug/Task/Story |
Categorize problem |
| Reporter/Assignee |
Who found/fixing |
Context on expertise |
| Created/Updated |
Timestamps |
Identify regressions |
| Components |
Affected modules |
Scope understanding |
| Versions |
Affected/Fix versions |
Version compatibility |
| Labels |
Tags like "regression" |
Pattern recognition |
| Environment |
Test/Prod, OS, versions |
Environment-specific fixes |
Automatically detects and structures:
- Steps to Reproduce → Numbered list
- Expected Behavior → Clear specification
- Actual Behavior → Problem description
- Error Details → Code-formatted stack traces
- Impact → Business context
- Workarounds → Temporary solutions
- Chronological order
- Author and timestamp
- Full discussion context
- Collapsible for readability
Linked Issues with Relationships
- Shows HOW issues are related
- Full context for each linked ticket
- Helps AI understand dependencies
Installation
Option 1: VS Code Extension (Recommended)
Prerequisites
- Visual Studio Code 1.60.0 or higher
- Java Runtime Environment (JRE) 8 or higher
- Network Access to your Jira instance (VPN required for on-premise)
- Jira Permissions: Read access to tickets
Installation Steps
Install Java (if not already installed)
# Verify Java installation
java -version
Install the Extension
- Open VS Code
- Go to Extensions (
Ctrl+Shift+X)
- Search for "Jira AI Resolver"
- Click Install
Verify Installation
- Open Command Palette (
Ctrl+Shift+P)
- Type "Jira AI Resolver"
- You should see "Jira AI Resolver: Run Export"
That's it! You're ready to export Jira tickets.
Option 2: Standalone JAR (Advanced Users)
Prerequisites
- Java 8 or higher
- Jira account with API access
- Personal Access Token or API Token
Building the Executable JAR
./gradlew clean jar
Or on Windows:
gradlew.bat clean jar
The executable JAR will be created at: build/libs/JiraExporter.jar
Setup
- Copy the JAR and config template to your working directory:
cp build/libs/JiraExporter.jar ./
cp config.properties.template config.properties
- Edit config.properties with your Jira credentials:
jira.url=https://jira.yourcompany.com
jira.user=your.email@company.com
jira.token=your-api-token-here
- Get Your Personal Access Token (Recommended)
- For on-premise Jira, generate a PAT at:
https://[your-jira]/jira/secure/ViewProfile.jspa
- Token should be 30+ characters for Bearer authentication
- Shorter passwords will use Basic authentication
Directory Structure
your-folder/
├── JiraExporter.jar # Executable JAR (all dependencies included)
└── config.properties # Your Jira configuration (keep this private!)
Run
java -jar JiraExporter.jar
Usage
VS Code Extension Usage
Step 1: Prepare Configuration File
Create a file named jira-config.properties (or any name ending in .properties, .config, or .txt):
jira.url=https://jira.yourcompany.com
jira.user=john.doe@company.com
jira.token=your-personal-access-token-or-password
How to get a Personal Access Token:
- On-premise Jira: Navigate to
https://your-jira-instance.com/jira/secure/ViewProfile.jspa
- Go to "Personal Access Tokens"
- Create a new token with "Read" permissions
- Copy the token (it will be 30+ characters long)
Step 2: Export Tickets from Jira
- Go to Jira and create a filter with the tickets you want to analyze
- Click "Export" → "Export CSV"
- Select only the "Issue key" column
- Save the CSV file (e.g.,
tickets.csv)
Example CSV format:
Issue key
SM-12345
SM-12346
SM-12347
Step 3: Run the Extension
- Open your workspace in VS Code
- Press
Ctrl+Shift+P (Windows/Linux) or Cmd+Shift+P (Mac)
- Type "Jira AI Resolver" and select "Run Export"
- The Jira AI Resolver panel opens:
- Click Browse next to "Configuration File"
- Select your
jira-config.properties file
- Click Browse next to "Ticket Export (CSV)"
- Select your CSV file with ticket IDs
- Click "Start Analysis"
Step 4: Monitor Progress
The extension displays:
- Total number of tickets to process
- Current progress (e.g., "Processing ticket 2/5")
- Current ticket ID being analyzed
- Visual progress bar
Step 5: Access Exported Files
When complete:
- A notification appears: "md files are created inside jira_exports folder"
- Click "Open Folder" to view the exports
- Find one
.md file per ticket in workspace/jira_exports/
Example output structure:
your-workspace/
└── jira_exports/
├── SM-12345.md
├── SM-12346.md
└── SM-12347.md
Standalone JAR Usage (Alternative)
If you prefer using the command line or don't have VS Code:
Basic Usage
$ java -jar JiraExporter.jar config.properties tickets.csv
Loaded configuration from config.properties
Using CSV file from command-line argument: tickets.csv
Total tickets to process: 3
========================================
Processing ticket 1/3: SM-12345
========================================
Fetching ticket: SM-12345
Successfully fetched ticket: SM-12345
Found 2 linked ticket(s). Fetching details...
Fetching linked ticket 1/2: SM-12340
Fetching linked ticket 2/2: SM-12320
Success! Saved to: jira_exports/SM-12345.md
Output Files
Both methods create markdown files with complete ticket information in AI-optimized format:
- Comprehensive metadata (status, priority, assignee, components, versions)
- Structured descriptions (steps to reproduce, expected vs actual behavior)
- Complete comment timeline
- Linked issues with relationship context
- Attachment metadata
- Subtasks status
- AI analysis instructions
AI Integration
Option 1: Claude.ai (Recommended)
- Go to claude.ai
- Start new conversation
- Upload
SM-12345.md
- Claude automatically generates Bug Analysis Document
Option 2: ChatGPT
- Go to chat.openai.com
- Start new chat
- Upload or paste
SM-12345.md contents
- Get analysis
Option 3: Google Gemini
- Go to gemini.google.com
- Start conversation
- Upload file or paste contents
- Receive analysis
Option 4: API Integration
# Claude API
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "content-type: application/json" \
-d "{
\"model\": \"claude-sonnet-4-5\",
\"messages\": [{
\"role\": \"user\",
\"content\": \"$(cat SM-12345.md)\"
}]
}"
Configuration
Authentication Methods
Personal Access Token (Bearer):
jira.token=NjQyMjY4NTA4NTg2Okrj5Y1dZHEkVRNPxBN0MF8xCuHB
Token length > 30 characters automatically uses Bearer auth.
Basic Authentication (Username + Password):
jira.user=john.doe@company.com
jira.token=your-password
Shorter tokens use Basic auth with Base64 encoding.
Custom Fields
If your Jira has custom fields, add them to appendTicketSummary():
// In JiraExporter.java, add after line 461:
if (fields.has("customfield_10100")) {
sb.append("**Severity:** ")
.append(fields.getString("customfield_10100"))
.append("\n");
}
Find custom field IDs in your Jira API responses.
Troubleshooting
VS Code Extension Issues
Issue: "Failed to start Java process"
Solution:
- Ensure Java is installed and in your system PATH
- Test by running
java -version in terminal
- On Windows: Add Java to PATH in System Environment Variables
- On Mac: Install Java via
brew install openjdk
- On Linux: Install via
sudo apt install default-jre (Ubuntu/Debian)
Issue: "Please open a workspace folder before running this command"
Solution:
- The extension requires an open workspace to save output files
- Open a folder:
File → Open Folder
- Select the folder where you want the
jira_exports directory created
Issue: Extension command not found
Solution:
- Verify extension is installed: Check Extensions panel (
Ctrl+Shift+X)
- Reload VS Code:
Developer: Reload Window from Command Palette
- Reinstall the extension if needed
Issue: "Execution Error: Process exited with code 1"
Solution:
- Check the VS Code Output panel for detailed Java error messages
- Verify your config file has correct credentials
- Ensure CSV file format is correct (only "Issue key" column)
- Check Java version compatibility:
java -version should show 8+
Issue: Progress bar stuck or not updating
Solution:
- Check your network/VPN connection
- The process may be waiting for rate limit retry (check Output panel)
- Large numbers of linked tickets can take time - be patient
- Check if Jira instance is accessible
General Issues
Issue: "Authentication Failed"
Solution:
- Verify token is not expired
- Check username is correct
- For on-premise Jira, use Personal Access Token
- Generate PAT at:
https://your-jira/jira/secure/ViewProfile.jspa
Issue: "403 Forbidden"
Solution:
- You may not have permission to view this ticket
- Try accessing in browser first
- Verify your API token has 'Read' permissions
Issue: "Rate limit hit"
Solution:
- Tool automatically retries with exponential backoff
- Wait for the retry delay (shown in console)
- Max 3 retries per ticket
Issue: "SSL Certificate Error"
Solution:
- For on-premise Jira with self-signed certs, the tool accepts all certificates
- This is intentional for corporate environments
- Only use with trusted Jira instances
CSV Batch Processing
One of the most powerful features is batch processing - export dozens or hundreds of tickets in one go!
Creating a CSV Export from Jira
Create a Filter in Jira:
- Navigate to Issues → Search for Issues
- Build your filter (e.g.,
project = "MYPROJECT" AND status = "Open" AND type = "Bug")
- Click Save As to save the filter
Export to CSV:
- Open your saved filter
- Click Export (top right) → Export CSV
- In the export dialog, uncheck all columns except "Issue key"
- Click Export
Use in Extension:
- Open the exported CSV in the Jira AI Resolver extension
- All tickets will be processed sequentially
- Progress bar shows current ticket number (e.g., "5 / 50")
Batch Export Best Practices
- Start Small: Test with 5-10 tickets first to verify configuration
- Reasonable Batches: Process 20-50 tickets at a time to avoid long sessions
- Rate Limits: The tool automatically handles rate limiting, but large batches take longer
- Monitoring: Watch the progress bar and current ticket ID to track progress
- Workspace: Ensure sufficient disk space for the output markdown files
Example: Exporting Entire Sprint Backlog
Issue key
PROJ-1001
PROJ-1002
PROJ-1003
PROJ-1004
PROJ-1005
PROJ-1006
PROJ-1007
PROJ-1008
PROJ-1009
PROJ-1010
Result: 10 markdown files in jira_exports/, ready for AI analysis!
Typical Processing Time
| Tickets |
Avg Linked Issues |
Total Time |
Files Created |
| 1 |
2 |
~10 seconds |
1 .md file |
| 5 |
2 each |
~1 minute |
5 .md files |
| 10 |
2 each |
~2 minutes |
10 .md files |
| 50 |
2 each |
~10 minutes |
50 .md files |
| 100 |
2 each |
~20 minutes |
100 .md files |
Times include automatic rate limit delays
Rate Limiting
- 3-second initial delay before first request
- 1-second delay between linked tickets
- Exponential backoff on 429 errors (10s, 20s, 40s)
- Respects
Retry-After header from server
Typical Export Times
- Single ticket: ~5 seconds
- Ticket + 2 linked issues: ~12 seconds
- Ticket + 5 linked issues: ~25 seconds
- Complex ticket with 10 links: ~50 seconds
Best Practices
1. Write Complete Jira Tickets
The quality of AI analysis depends on ticket quality:
- ✅ Include full error messages and stack traces
- ✅ Add clear reproduction steps
- ✅ Describe expected vs actual behavior
- ✅ Attach screenshots and logs
- ✅ Link related issues
2. Review AI Analysis
AI is powerful but not infallible:
- ✅ Verify root cause makes sense
- ✅ Check code changes for edge cases
- ✅ Ensure tests are comprehensive
- ✅ Consider security implications
3. Document Everything
- ✅ Save Bug Analysis Documents in repository
- ✅ Reference in pull requests
- ✅ Build knowledge base over time
- ✅ Share learnings with team
4. Iterate with AI
- ✅ Ask follow-up questions
- ✅ Request alternative approaches
- ✅ Get clarification on complex parts
- ✅ Refine until satisfied
Examples
Real-World Time Savings
Before JiraExporter + AI:
- Reading Jira ticket: 10 min
- Reproducing bug: 30 min
- Debugging root cause: 2-4 hours
- Writing fix: 1-2 hours
- Writing tests: 30-60 min
- Total: 5-8 hours
After JiraExporter + AI:
- Run export: 2 min
- Upload to AI: 1 min
- Review analysis: 15 min
- Apply code changes: 30 min
- Run tests: 5 min
- Total: ~1 hour
Improvement: 80-90% time reduction
Limitations
What AI Can Do
✅ Identify root causes from stack traces
✅ Suggest code fixes with examples
✅ Generate test cases
✅ Assess impact and risks
✅ Explain complex issues
What AI Cannot Do
❌ Access your private codebase directly
❌ Execute code changes automatically
❌ Test the fix in your environment
❌ Deploy to production
❌ Replace human judgment
Important: AI provides analysis and code snippets. You review and implement changes - AI does NOT directly modify your files.
Contributing
Improvements welcome! Areas for enhancement:
- Additional metadata fields
- More intelligent section detection
- Support for other issue trackers (GitHub, GitLab, Azure DevOps)
- Additional AI provider integrations
- Template customization
Why Choose Jira AI Resolver?
For Individual Developers
- 🚀 10x Faster Bug Resolution: Turn 4-hour debugging sessions into 30-minute tasks
- 🧠 AI-Powered Insights: Get root cause analysis and fix suggestions from Claude, ChatGPT, or Gemini
- 📋 Complete Context: Never miss important details - linked issues, comments, attachments all captured
- 💼 Professional Output: Clean, well-formatted markdown ready for AI analysis
For Development Teams
- 📊 Batch Processing: Export and analyze your entire sprint backlog
- 🔄 Consistent Analysis: Same structured format for every bug
- 📚 Knowledge Base: Build a repository of bug analyses for future reference
- 🎯 Faster Onboarding: New team members can understand complex bugs quickly
For Technical Leads
- ⏱️ Time Savings: 80-90% reduction in bug resolution time
- 📈 Better Estimates: Historical data on bug complexity and resolution
- 🔍 Quality Insights: Identify patterns and recurring issues across backlog
- 💡 Smart Prioritization: Understand impact and dependencies before assignment
Screenshots
Main Interface
The Jira AI Resolver panel provides an intuitive interface:
- Configuration file browser (supports
.properties, .config, .txt)
- CSV ticket list browser
- VPN connectivity reminder
- Visual file selection indicators
Progress Tracking
Real-time progress display shows:
- Current ticket number out of total (e.g., "5 / 50")
- Current ticket ID being processed
- Visual progress bar
- Success/error status
Output Files
Generated markdown files include:
- Comprehensive ticket metadata
- Structured description sections
- Complete comment timeline
- Linked issues with full context
- AI analysis instructions template
Version History
v2.0 - VS Code Extension Release
- 🎨 NEW: VS Code Extension with beautiful GUI interface
- 🎯 NEW: Real-time Progress Tracking with visual progress bar
- 📁 NEW: Native File Browsers for config and CSV selection
- 🔔 NEW: Success Notifications with quick folder access
- 📊 NEW: CSV Batch Processing with visual feedback
- ✅ Comprehensive metadata capture (15+ fields)
- ✅ Intelligent description formatting
- ✅ Enhanced comments timeline
- ✅ Linked issues with relationship context
- ✅ Attachment metadata
- ✅ Subtasks tracking
- ✅ Structured AI analysis instructions
- ✅ Complete documentation suite
v1.0 - Initial Release
- Basic Jira ticket export (command-line only)
- Simple markdown format
- Linked issues support
Frequently Asked Questions
Can I use this with Jira Cloud?
Yes! The extension works with both on-premise Jira instances and Jira Cloud. Make sure your token has appropriate permissions.
Does this work with other issue trackers?
Currently, only Jira is supported. GitHub Issues, GitLab, and Azure DevOps support are planned for future releases.
Is my Jira data sent to any external servers?
No! All processing happens locally on your machine. The extension only communicates directly with your Jira instance.
The current version uses a fixed format optimized for AI analysis. Custom templates are planned for a future release.
We recommend:
- Claude (claude.ai) - Excellent for code analysis and bug fixes
- ChatGPT (chat.openai.com) - Great for general analysis
- Gemini (gemini.google.com) - Good for pattern recognition
All three handle the markdown format well and provide quality analysis.
How many tickets can I export at once?
Technically unlimited, but we recommend batches of 20-50 tickets for practical session lengths. Rate limiting means 100 tickets might take 20-30 minutes.
What Java version do I need?
Java 8 or higher. Both JRE (Java Runtime Environment) and JDK (Java Development Kit) work fine.
Support & Contributing
Getting Help
- 📖 Documentation: This README and linked guides
- 🐛 Bug Reports: Create an issue on GitHub
- 💡 Feature Requests: Open a GitHub issue with the "enhancement" label
- ❓ Questions: Check the FAQ section above
Contributing
Contributions welcome! Areas for enhancement:
- Additional metadata fields extraction
- Custom export templates
- Support for GitHub Issues, GitLab, Azure DevOps
- Direct AI integration (Claude API, OpenAI API)
- Custom field mapping UI
- Export format options (PDF, HTML)
License
[Your license here]
Start using Jira AI Resolver today and experience 10x faster bug resolution with AI-powered analysis!
🔗 Marketplace: [VS Code Marketplace Link]
🐙 GitHub: [Your GitHub Repository]
📧 Contact: [Your Contact Info]
