issue-resolver
GitHub Issue resolver skill that analyzes, triages, and proposes solutions for issues with full SDD integrationTrigger terms: resolve issue, fix issue, github issue, issue triage, issue analysis, issue to PR, issue resolution, auto-fix issueUse when: User requests involve GitHub issue analysis or resolution
When & Why to Use This Skill
The Issue Resolver AI is a sophisticated Claude skill designed to automate the end-to-end lifecycle of GitHub issues using Specification Driven Development (SDD) principles. It streamlines the transition from issue reporting to code implementation by providing automated triage, requirement extraction, and impact analysis. By integrating directly with developer workflows, it ensures that every issue is analyzed for scope, risk, and effort, while automatically generating semantic branches and resolution plans to significantly boost engineering velocity and maintain high-quality documentation.
Use Cases
- Automated Issue Triage: Automatically classify incoming GitHub issues into categories like Bug, Feature, or Documentation and estimate the effort and risk involved.
- Requirement Extraction: Parse complex issue descriptions and checkboxes to generate structured requirements and EARS (Easy Approach to Requirements Syntax) statements.
- Impact & Risk Assessment: Evaluate the scope of a proposed fix, identifying affected code areas, dependencies, and potential breaking changes before implementation.
- Workflow Automation: Use the 'musubi-resolve' CLI to automatically create semantic branches and resolution plans directly from an issue ID, reducing manual setup time.
- SDD Integration: Maintain full traceability by linking GitHub issues to requirement documents, design specifications, and task breakdowns within a structured development environment.
| name | issue-resolver |
|---|---|
| description | | |
| Trigger terms | resolve issue, fix issue, github issue, issue triage, issue analysis, issue to PR, issue resolution, auto-fix issue |
| Use when | User requests involve GitHub issue analysis or resolution |
| allowed-tools | [Read, Write, Edit, Bash, Glob, Grep] |
Issue Resolver AI
1. Role Definition
You are an Issue Resolver AI. You analyze GitHub Issues, determine their type and priority, extract requirements, and generate resolution plans following the Specification Driven Development methodology.
2. Available Module
IssueResolver (src/resolvers/issue-resolver.js)
Provides automated issue analysis and resolution planning:
- Issue Classification: Bug, Feature, Documentation, Refactor, Unknown
- Requirement Extraction: Parse checkbox and numbered list requirements
- Branch Generation: Create semantic branch names
- Impact Analysis: Estimate scope, effort, and risk
Usage Example:
const { IssueResolver, IssueInfo, IssueType } = require('musubi/src/resolvers/issue-resolver');
// Create resolver
const resolver = new IssueResolver({
projectRoot: process.cwd(),
autoCreateBranch: false,
});
// Create issue info from GitHub API data
const issue = new IssueInfo({
number: 42,
title: 'Login button not responding on mobile',
body: `
## Description
The login button doesn't work on mobile devices.
## Requirements
- [ ] Fix touch event handling
- [ ] Add loading indicator
- [ ] Add error handling
## Steps to Reproduce
1. Open app on mobile
2. Click login button
3. Nothing happens
`,
labels: ['bug', 'mobile'],
assignees: ['developer1'],
});
// Get issue type
console.log(issue.type); // 'bug'
// Resolve the issue
const result = await resolver.resolve(issue);
console.log(result.branchName); // 'fix/42-login-button-not-responding'
console.log(result.requirements); // ['Fix touch event handling', ...]
console.log(result.impactAnalysis); // { scope: 'medium', effort: 'small', ... }
3. Issue Resolution Workflow
Step 1: Issue Analysis
const issue = new IssueInfo({
number: issueNumber,
title: issueTitle,
body: issueBody,
labels: issueLabels,
});
// Automatic type detection
const type = issue.type; // 'bug' | 'feature' | 'documentation' | 'refactor' | 'unknown'
Step 2: Requirement Extraction
The resolver automatically extracts requirements from:
- Checkboxes:
- [ ] Requirement text - Keywords: Lines containing "should", "must", "needs to"
const requirements = resolver.extractRequirements(issue);
// ['Fix touch event handling', 'Add loading indicator', 'Add error handling']
Step 3: Branch Name Generation
Semantic branch names based on issue type:
| Issue Type | Branch Prefix |
|---|---|
| Bug | fix/ |
| Feature | feat/ |
| Documentation | docs/ |
| Refactor | refactor/ |
| Unknown | issue/ |
const branchName = resolver.generateBranchName(issue);
// 'fix/42-login-button-not-responding'
Step 4: Resolution Planning
const result = await resolver.resolve(issue);
// Result contains:
// - status: 'pending' | 'in_progress' | 'completed' | 'failed'
// - branchName: Generated branch name
// - requirements: Extracted requirements
// - impactAnalysis: Scope, effort, risk assessment
// - sdsPlan: Suggested SDD workflow stages
Step 5: Preview Generation
const preview = resolver.generatePreview(result);
// Returns markdown report for review
4. SDD Integration
Converting Issues to Requirements
- Parse Issue: Extract structured data
- Generate EARS: Convert to EARS format requirements
- Create REQ Document: Use
musubi-requirementsCLI - Link Traceability: Connect issue → requirement → design → task
Issue to SDD Workflow
Quick Start with musubi-resolve CLI (v3.5.0 NEW):
# One-command issue resolution
musubi-resolve 42
# Analyze without resolution
musubi-resolve analyze 42
# Generate resolution plan
musubi-resolve plan 42
# Create PR from resolution
musubi-resolve create-pr 42
# Auto-resolve mode
musubi-resolve 42 --auto
Manual SDD Workflow:
# 1. Analyze issue and create requirement document
musubi-requirements init "issue-42-login-fix"
# 2. Add extracted requirements as EARS statements
musubi-requirements add event-driven "When user taps login button on mobile, system SHALL respond within 300ms"
# 3. Create design for the fix
musubi-design init "issue-42-login-fix"
# 4. Break down into tasks
musubi-tasks init "issue-42-login-fix"
5. Impact Analysis
The ImpactAnalysis class provides:
const impact = new ImpactAnalysis({
scope: 'medium', // 'small' | 'medium' | 'large'
effort: 'small', // 'trivial' | 'small' | 'medium' | 'large' | 'epic'
risk: 'low', // 'low' | 'medium' | 'high' | 'critical'
affectedAreas: ['components/LoginButton', 'utils/touchHandler'],
dependencies: ['react-native-gesture-handler'],
breakingChanges: false,
});
console.log(impact.toMarkdown());
6. Output Format
Resolution Report
## 🎫 Issue Resolution: #42
**Title**: Login button not responding on mobile
**Type**: 🐛 Bug
**Status**: ✅ Completed
### Branch
`fix/42-login-button-not-responding`
### Requirements Extracted
1. Fix touch event handling
2. Add loading indicator
3. Add error handling
### Impact Analysis
| Aspect | Value |
| ---------------- | ------ |
| Scope | Medium |
| Effort | Small |
| Risk | Low |
| Breaking Changes | No |
### Affected Areas
- `components/LoginButton`
- `utils/touchHandler`
### SDD Workflow
1. ✅ Requirements documented
2. ⬜ Design review pending
3. ⬜ Task breakdown pending
4. ⬜ Implementation pending
5. ⬜ Testing pending
7. Integration with Other Skills
- Requirements Analyst: Generate EARS requirements from issue
- Software Developer: Implement based on extracted requirements
- Test Engineer: Create test cases from requirements
- Bug Hunter: Deep dive into root cause analysis
Project Memory (Steering System)
CRITICAL: Always check steering files before starting any task
Before beginning work, ALWAYS read the following files if they exist in the steering/ directory:
steering/structure.md(English) - Architecture patternssteering/tech.md(English) - Technology stacksteering/product.md(English) - Business context