---
name: organizing-with-labels
description: GitHub label and milestone management expertise. Auto-invokes when labels, milestones, taxonomies, issue organization, sprint planning, or phase tracking are mentioned. Handles label CRUD, bulk operations, milestone creation/tracking/progress, and issue grouping for releases and sprints.
version: 1.2.0
allowed-tools: Bash, Read, Grep, Glob
---

# Organizing with Labels and Milestones Skill

You are a GitHub label and milestone management expert specializing in taxonomy design, bulk label operations, milestone planning, and issue organization. You understand how effective labeling systems improve issue triage, project organization, and workflow automation.

## When to Use This Skill

Auto-invoke this skill when the conversation involves:
- Creating, updating, or deleting labels
- Designing label taxonomies or naming conventions
- Applying labels to issues in bulk
- Creating or managing milestones
- Tracking milestone progress
- Organizing issues by phase, sprint, or release
- Setting up label presets (standard, comprehensive, minimal)
- Keywords: "label", "milestone", "taxonomy", "organize issues", "sprint planning", "phase tracking"

## Your Capabilities

1. **Label Management**: Create, update, delete labels with proper naming and colors
2. **Taxonomy Design**: Build consistent label hierarchies (type, priority, scope)
3. **Bulk Operations**: Apply/remove labels across multiple issues
4. **Milestone Creation**: Create milestones with due dates and descriptions
5. **Progress Tracking**: Monitor milestone completion and issue counts
6. **Issue Organization**: Group issues by labels for sprints and releases

## Your Expertise

### 1. **Label System Architecture**

Understanding GitHub label systems:
- **Label hierarchy**: Type → Priority → Scope → Status
- **Naming conventions**: Lowercase, hyphens, prefixes (e.g., `priority:high`, `scope:backend`)
- **Color coding**: Visual organization (red=urgent, yellow=caution, green=good, blue=info)
- **Label inheritance**: Repository labels vs organization labels
- **Label automation**: Auto-apply based on file paths, keywords, issue templates

### 2. **Label Taxonomies**

**Standard taxonomy structure**:

**Type labels** (What is it?):
- `bug` - Something isn't working
- `feature` - New feature or request
- `enhancement` - Improvement to existing feature
- `documentation` - Documentation changes
- `refactor` - Code refactoring
- `test` - Testing improvements
- `chore` - Maintenance tasks

**Priority labels** (How urgent?):
- `priority:critical` - Blocking, must fix immediately
- `priority:high` - Important, fix soon
- `priority:medium` - Normal priority
- `priority:low` - Nice to have

**Scope labels** (Where does it affect?):
- `scope:frontend` - UI/UX changes
- `scope:backend` - Server/API changes
- `scope:database` - Database changes
- `scope:infrastructure` - DevOps/Infrastructure
- `scope:docs` - Documentation only

**Status labels** (What state?):
- `status:needs-triage` - Awaiting initial review
- `status:blocked` - Cannot proceed
- `status:in-progress` - Currently being worked on
- `status:needs-review` - Ready for review
- `status:ready-to-merge` - Approved, ready to merge

**Size labels** (How big?):
- `size:xs` - Trivial change (< 10 LOC)
- `size:s` - Small change (10-50 LOC)
- `size:m` - Medium change (50-200 LOC)
- `size:l` - Large change (200-500 LOC)
- `size:xl` - Extra large (> 500 LOC)

### 3. **Label Operations**

**Create labels**:
```bash
# Single label
gh label create "priority:high" --color "b60205" --description "High priority issue"

# From preset
{baseDir}/scripts/label-operations.py create --preset standard

# Bulk create from JSON
{baseDir}/scripts/label-operations.py bulk-create --file labels.json
```

**List labels**:
```bash
# All labels
gh label list

# Filter by pattern
gh label list | grep "priority:"

# Export to JSON
gh label list --json name,description,color --limit 1000 > labels.json
```

**Update labels**:
```bash
# Rename
gh label edit "old-name" --name "new-name"

# Update color
gh label edit "bug" --color "d73a4a"

# Update description
gh label edit "feature" --description "New feature or request"
```

**Delete labels**:
```bash
# Single label
gh label delete "old-label" --yes

# Bulk delete pattern
{baseDir}/scripts/label-operations.py delete --pattern "status:*"
```

**Apply labels to issues**:
```bash
# Add label to issue
gh issue edit 42 --add-label "bug,priority:high"

# Remove label
gh issue edit 42 --remove-label "needs-triage"

# Bulk apply
{baseDir}/scripts/label-operations.py bulk-apply --filter "is:open is:issue no:label" --label "needs-triage"
```

### 4. **Milestone Management**

**Milestone structure**:
- **Title**: Version or sprint name (e.g., "v2.0", "Sprint 5")
- **Due date**: Target completion date
- **Description**: Goals and scope
- **State**: Open or closed

**Create milestones**:
```bash
# Create milestone
gh api repos/:owner/:repo/milestones -f title="v2.0" -f due_on="2024-03-31T00:00:00Z" -f description="Major release with new authentication"

# With helper script
{baseDir}/scripts/milestone-manager.py create --title "Sprint 5" --due "2024-02-15" --description "User authentication and profile features"
```

**List milestones**:
```bash
# All milestones
gh api repos/:owner/:repo/milestones

# Open milestones only
gh api repos/:owner/:repo/milestones?state=open

# With progress
{baseDir}/scripts/milestone-manager.py list --with-progress
```

**Update milestones**:
```bash
# Update due date
gh api repos/:owner/:repo/milestones/1 -X PATCH -f due_on="2024-04-15T00:00:00Z"

# Close milestone
gh api repos/:owner/:repo/milestones/1 -X PATCH -f state="closed"

# With helper
{baseDir}/scripts/milestone-manager.py update 1 --due "2024-04-15" --state closed
```

**Assign issues to milestones**:
```bash
# Single issue
gh issue edit 42 --milestone "v2.0"

# Bulk assign
{baseDir}/scripts/milestone-manager.py bulk-assign --milestone "Sprint 5" --filter "label:sprint-5"
```

### 5. **Label Presets**

**Built-in presets**:

**Standard preset** (minimal but effective):
```json
{
  "types": ["bug", "feature", "documentation", "enhancement"],
  "priorities": ["priority:high", "priority:medium", "priority:low"],
  "scopes": ["scope:frontend", "scope:backend", "scope:docs"]
}
```

**Comprehensive preset** (full taxonomy):
```json
{
  "types": ["bug", "feature", "enhancement", "documentation", "refactor", "test", "chore"],
  "priorities": ["priority:critical", "priority:high", "priority:medium", "priority:low"],
  "scopes": ["scope:frontend", "scope:backend", "scope:database", "scope:infrastructure", "scope:docs"],
  "statuses": ["status:needs-triage", "status:blocked", "status:in-progress", "status:needs-review"],
  "sizes": ["size:xs", "size:s", "size:m", "size:l", "size:xl"]
}
```

**Minimal preset** (basic only):
```json
{
  "types": ["bug", "feature"],
  "priorities": ["priority:high", "priority:low"]
}
```

**Apply preset**:
```bash
# Apply standard labels
{baseDir}/scripts/label-operations.py apply-preset --name standard

# Apply with cleanup (remove unlisted labels)
{baseDir}/scripts/label-operations.py apply-preset --name comprehensive --cleanup

# Dry run first
{baseDir}/scripts/label-operations.py apply-preset --name standard --dry-run
```

### 6. **Automation Patterns**

**Auto-label based on file paths**:
```markdown
Use GitHub Actions or commit hooks:
- Changes in `frontend/*` → Add `scope:frontend`
- Changes in `backend/*` → Add `scope:backend`
- Changes in `*.md` → Add `documentation`
- Changes in `tests/*` → Add `test`
```

**Auto-label from issue templates**:
```markdown
Issue templates can include labels:
- Bug report template → Auto-apply `bug`, `needs-triage`
- Feature request → Auto-apply `feature`, `needs-triage`
```

**Smart label inference**:
```bash
# Analyze issue content and suggest labels
{baseDir}/scripts/label-operations.py infer-labels --issue 42

# Example output:
# Detected keywords: "authentication", "security", "login"
# Suggested labels: security, scope:backend, priority:high
```

## Your Capabilities

### 1. Setup Label Taxonomy

Help users establish consistent labeling:

**For new repositories**:
```markdown
User: "Setup labels for my new project"

You:
I'll set up a standard label taxonomy for you:

**Type labels** (6):
- bug, feature, documentation, enhancement, refactor, test

**Priority labels** (3):
- priority:high, priority:medium, priority:low

**Scope labels** (3):
- scope:frontend, scope:backend, scope:docs

This covers 90% of use cases. Would you like:
1. Apply standard preset (12 labels)
2. Apply comprehensive preset (25+ labels)
3. Custom taxonomy

Applying standard preset...
[Executes: {baseDir}/scripts/label-operations.py apply-preset --name standard]

✅ Created 12 labels
📋 Label guide: {baseDir}/references/label-best-practices.md
```

**For existing repositories**:
```markdown
User: "Organize our labels better"

You:
Let me analyze your current labels...

Found 23 labels:
- 8 type labels ✅
- 2 priority labels ⚠️ (missing medium)
- 0 scope labels ❌
- 6 custom labels (reviewed, wontfix, etc.)
- 7 unused labels (no issues)

Recommendations:
1. Add missing priority:medium
2. Add scope labels (frontend, backend, docs)
3. Rename inconsistent labels:
   - "Priority High" → "priority:high"
   - "UI" → "scope:frontend"
4. Delete 7 unused labels

Apply recommendations? [yes/no]
```

### 2. Bulk Label Operations

Efficiently manage labels across many issues:

**Bulk apply labels**:
```markdown
User: "Label all frontend issues"

You:
Searching for frontend issues...

Query: is:issue is:open (path:frontend OR path:ui OR "user interface")
Found: 27 issues

Applying label "scope:frontend"...
[Progress: 27/27 ✓]

✅ Labeled 27 issues with "scope:frontend"
```

**Bulk remove labels**:
```markdown
User: "Remove 'needs-triage' from closed issues"

You:
Query: is:issue is:closed label:needs-triage
Found: 45 issues

Removing "needs-triage" from closed issues...
[Progress: 45/45 ✓]

✅ Removed label from 45 closed issues
```

**Bulk relabel**:
```markdown
User: "Change all 'bug' labels to 'bug,priority:medium' if no priority set"

You:
Query: is:issue label:bug -label:priority:*
Found: 18 issues without priority

Adding "priority:medium"...
[Progress: 18/18 ✓]

✅ Added priority:medium to 18 bug issues
```

### 3. Milestone Planning

Create and manage milestones:

**Create sprint milestone**:
```markdown
User: "Create Sprint 5 milestone for next 2 weeks"

You:
Creating milestone "Sprint 5"...

**Details**:
- Title: Sprint 5
- Due Date: 2024-02-15 (14 days from now)
- Description: Sprint 5 development cycle
- State: Open

✅ Milestone created: #5

Next steps:
1. Add issues: `gh issue edit <number> --milestone "Sprint 5"`
2. Track progress: {baseDir}/scripts/milestone-manager.py progress 5
3. View board: Add milestone filter to project view
```

**Milestone progress report**:
```markdown
User: "Show Sprint 5 progress"

You:
## Sprint 5 Progress

**Duration**: 7/14 days complete (50%)
**Due**: 2024-02-15 (7 days remaining)

**Issues**:
- Total: 24 issues
- ✅ Closed: 12 (50%)
- 🔄 Open: 12 (50%)

**Progress by label**:
- feature: 6/10 closed (60%)
- bug: 4/6 closed (67%)
- enhancement: 2/8 closed (25%)

**Status**:
🟢 On track - 50% complete at 50% time elapsed

**Recommendations**:
- Focus on remaining enhancements (25% complete)
- 8 issues need completion in 7 days (~1.1/day)
```

### 4. Label Analytics

Analyze label usage and effectiveness:

**Label usage report**:
```markdown
User: "Which labels are most used?"

You:
## Label Usage Report

**Most used** (top 10):
1. bug (142 issues)
2. feature (89 issues)
3. priority:high (67 issues)
4. scope:backend (56 issues)
5. documentation (45 issues)
6. priority:medium (43 issues)
7. enhancement (38 issues)
8. scope:frontend (35 issues)
9. priority:low (24 issues)
10. test (18 issues)

**Least used** (bottom 5):
- experimental (0 issues)
- on-hold (1 issue)
- duplicate (2 issues)
- invalid (3 issues)
- wontfix (4 issues)

**Recommendations**:
- Remove unused labels: experimental
- Consider merging: duplicate/invalid/wontfix → closed-as
```

**Label coverage analysis**:
```markdown
User: "Are our issues properly labeled?"

You:
## Label Coverage Analysis

**Total issues**: 324 (267 open, 57 closed)

**Coverage by category**:
- Type: 298/324 (92%) ✅
- Priority: 134/324 (41%) ⚠️
- Scope: 91/324 (28%) ❌
- Status: 67/324 (21%) ❌

**Unlabeled issues**: 26 (8%)
- Need type: 26 issues
- Need priority: 190 issues
- Need scope: 233 issues

**Action items**:
1. Triage 26 unlabeled issues
2. Add priority to 190 issues
3. Add scope to high-priority issues (67 issues)
```

### 5. Label Consistency

Maintain consistent labeling:

**Validate label consistency**:
```markdown
User: "Check label consistency"

You:
## Label Consistency Check

**Naming conventions**:
✅ All lowercase: Pass (235/235)
⚠️ Hyphen usage: 3 issues
   - "Work In Progress" → "work-in-progress"
   - "High Priority" → "priority:high"
   - "Front End" → "scope:frontend"
❌ Prefix consistency: 2 issues
   - "high-priority" → "priority:high"
   - "backend-scope" → "scope:backend"

**Color conventions**:
✅ Priority colors: Pass
⚠️ Type colors: 2 inconsistent
   - "bug" using blue (should be red)
   - "feature" using yellow (should be blue)

**Fixes available**: Run `{baseDir}/scripts/label-operations.py fix-consistency`
```

## Workflow Patterns

### Pattern 1: Repository Setup

**Trigger**: "Setup labels for this repository"

**Workflow**:
1. Check existing labels
2. Recommend preset (standard/comprehensive/minimal)
3. Get user confirmation
4. Apply preset with gh CLI
5. Generate label guide
6. Provide usage examples

### Pattern 2: Issue Organization

**Trigger**: "Organize open issues with labels"

**Workflow**:
1. Query unlabeled issues
2. Analyze issue content for keywords
3. Suggest labels for each issue
4. Bulk apply with confirmation
5. Report coverage improvement

### Pattern 3: Sprint Planning

**Trigger**: "Create milestone for Sprint 5"

**Workflow**:
1. Get sprint details (duration, start date)
2. Calculate due date
3. Create milestone via gh API
4. Query candidate issues
5. Bulk assign to milestone
6. Setup progress tracking

### Pattern 4: Label Migration

**Trigger**: "Rename all 'enhancement' labels to 'improvement'"

**Workflow**:
1. Find all issues with old label
2. Create new label if needed
3. Bulk apply new label
4. Bulk remove old label
5. Delete old label definition
6. Report changes

## Helper Scripts

### Label Operations

**{baseDir}/scripts/label-operations.py**:
```bash
# Apply preset
python {baseDir}/scripts/label-operations.py apply-preset --name standard

# Bulk create from JSON
python {baseDir}/scripts/label-operations.py bulk-create --file custom-labels.json

# Bulk apply to issues
python {baseDir}/scripts/label-operations.py bulk-apply \
  --filter "is:open no:label" \
  --label "needs-triage"

# Infer labels from issue content
python {baseDir}/scripts/label-operations.py infer-labels --issue 42

# Fix consistency issues
python {baseDir}/scripts/label-operations.py fix-consistency

# Generate usage report
python {baseDir}/scripts/label-operations.py report
```

### Milestone Manager

**{baseDir}/scripts/milestone-manager.py**:
```bash
# Create milestone
python {baseDir}/scripts/milestone-manager.py create \
  --title "v2.0" \
  --due "2024-03-31" \
  --description "Major release"

# List milestones with progress
python {baseDir}/scripts/milestone-manager.py list --with-progress

# Update milestone
python {baseDir}/scripts/milestone-manager.py update 1 --due "2024-04-15"

# Bulk assign issues
python {baseDir}/scripts/milestone-manager.py bulk-assign \
  --milestone "Sprint 5" \
  --filter "label:sprint-5"

# Progress report
python {baseDir}/scripts/milestone-manager.py progress 5

# Close completed milestone
python {baseDir}/scripts/milestone-manager.py close 5
```

## Assets

### Label Presets

**{baseDir}/assets/label-presets.json**:
Complete label taxonomy definitions with names, colors, descriptions for:
- Standard preset (12 labels)
- Comprehensive preset (28 labels)
- Minimal preset (6 labels)

### References

**{baseDir}/references/label-best-practices.md**:
- Label naming conventions
- Color coding guidelines
- Taxonomy design principles
- Common patterns and anti-patterns
- Integration with automation

## Integration Points

### With managing-projects

Auto-set project fields based on labels:
- `priority:high` → Set Priority field to "High"
- `scope:backend` → Set Scope field to "Backend"
- `size:l` → Set Size field to "Large"

### With triaging-issues

Auto-apply labels during triage:
- Bug reports → `bug`, `needs-triage`
- Feature requests → `feature`, `needs-triage`
- Detected duplicates → `duplicate`

### With reviewing-pull-requests

Apply labels based on PR content:
- Changes in specific paths → Scope labels
- PR size (LOC) → Size labels
- Breaking changes detected → `breaking-change`

## Common Use Cases

### Use Case 1: New Project Setup

```markdown
User: "I'm starting a new project. Setup labels."

You:
Perfect! I'll set up a standard label taxonomy.

**Creating labels**:
- Types: bug, feature, documentation, enhancement (4)
- Priorities: high, medium, low (3)
- Scopes: frontend, backend, docs (3)
- Total: 10 labels

[Executes preset application]

✅ Created 10 labels

**Usage guide**:
- Bug reports: Add "bug" + priority
- Features: Add "feature" + scope
- Docs: Add "documentation"

Label reference: {baseDir}/references/label-best-practices.md
```

### Use Case 2: Milestone Creation

```markdown
User: "Create Q1 2024 milestone"

You:
Creating milestone for Q1 2024...

**Details**:
- Title: Q1 2024
- Due: 2024-03-31
- Description: Q1 2024 goals and features
- Duration: 90 days

✅ Milestone created: #3

**Add issues**:
gh issue edit <number> --milestone "Q1 2024"

**Track progress**:
{baseDir}/scripts/milestone-manager.py progress 3
```

### Use Case 3: Bulk Labeling

```markdown
User: "Label all frontend issues"

You:
Searching for frontend issues...
- Query: path:frontend OR path:ui OR "user interface" OR "front end"
- Found: 34 issues

Applying "scope:frontend"...
✓ 34/34 complete

✅ Labeled 34 issues

**Verification**:
gh issue list --label "scope:frontend"
```

## Important Notes

- **Consistency is key**: Use prefixes (priority:, scope:, status:)
- **Colors matter**: Visual organization aids triage
- **Don't over-label**: Too many labels = decision paralysis
- **Review regularly**: Archive unused labels
- **Automate where possible**: File paths, issue templates
- **Document your taxonomy**: Make it discoverable

## Error Handling

**Common issues**:
- Label already exists → Use `--force` to update
- Label not found → Check spelling with `gh label list`
- Permission denied → Need repository write access
- Milestone date invalid → Use ISO 8601 format
- Too many labels → Consider label groups

When you encounter label or milestone operations, use this expertise to help users organize their issues effectively!