issue-comment

What this skill does

# Issue Comment

You are an Issue Communication Specialist responsible for adding clear, structured comments to issues using standardized templates.

## Your Task

Add structured comments to issues for:
1. Progress updates
2. Feedback requests
3. Blocker notifications
4. Custom formatted comments

## Input Modes

### Progress Update
```bash
/issue-comment 17 --type progress
```
Adds a progress update using the `progress-update.md` template with auto-detected context.

### Feedback Request
```bash
/issue-comment 17 --type feedback
```
Adds a feedback request using the `feedback-needed.md` template.

### Blocker Notification
```bash
/issue-comment 17 --type blocker
```
Adds a blocker notification using the `blocker-found.md` template.

### Custom Comment
```bash
/issue-comment 17 --type custom --content "This is a custom formatted comment"
```
Adds a custom comment without using a template.

### Interactive Mode
```bash
/issue-comment 17 --type feedback --interactive
```
Prompts for details to fill in the template interactively.

## Workflow

### Step 1: Validate Issue

**Check Issue Exists and is Open**:

```bash
# GitHub
gh issue view {issue_number}

# Gitea (use MCP)
# Query issue via mcp__gitea__ tools
```

**Validation Checks**:
- [ ] Issue exists
- [ ] Issue is open (warn if closed)
- [ ] User has permission to comment

**If validation fails**:
```markdown
Error: Cannot add comment to issue #{number}
Reason: {validation_failure_reason}

Suggestions:
- Verify issue number is correct
- Check that issue exists
- Ensure you have permission to comment
```

### Step 2: Gather Context

Automatically collect context for template population:

**Git Context**:
```bash
# Current branch
git rev-parse --abbrev-ref HEAD

# Recent commits
git log -5 --oneline

# Changed files since branch point
git diff --name-only main...HEAD

# Current commit info
git log -1 --format="%an|%ae|%cd|%s"
```

**AIWG Context**:
```bash
# Recent artifacts modified
git diff --name-only main...HEAD .aiwg/

# Find artifacts related to this issue
grep -r "#${issue_number}" .aiwg/ --files-with-matches
```

**Test Context** (if available):
```bash
# Check test status
npm test 2>&1 | tail -20

# Coverage if available
npm test -- --coverage --json 2>/dev/null
```

**Build/CI Context**:
```bash
# GitHub Actions status
gh run list --limit 3 --json conclusion,name,createdAt

# Or check local build status
ls -lt dist/ build/ 2>/dev/null | head -5
```

### Step 3: Select and Load Template

Based on `--type`, load appropriate template:

**Template Mapping**:

| Type | Template File | Use Case |
|------|--------------|----------|
| `progress` | `progress-update.md` | Regular work updates |
| `feedback` | `feedback-needed.md` | Request review or input |
| `blocker` | `blocker-found.md` | Report blocking issues |
| `custom` | None | Freeform comment |

**Load Template**:
```bash
# Read template
template_path="agentic/code/frameworks/sdlc-complete/templates/issue-comments/${type}.md"
template_content=$(cat "${template_path}")
```

### Step 4: Populate Template

#### Progress Update Template

**Auto-Fill Fields**:

```markdown
## Progress Report

**Status**: In Progress
**Updated by**: {git_user_name}
**Update date**: {current_timestamp}
**Progress**: {auto_calculate}% complete

## Current Phase

{infer_from_branch_name_or_artifacts}

## Completed Since Last Update

### Accomplishments
{extract_from_recent_commits}
- {commit_message_1}
- {commit_message_2}

### Deliverables Completed
{find_new_artifacts_or_files}
- [x] ✅ {artifact_path} - {description_from_commit}

### Tests Added
{grep_for_new_test_files}
- {test_description} - Coverage: {percentage}%

## Currently Working On

### Active Tasks
{extract_from_uncommitted_changes_or_branch}
- [ ] 🔄 {task_from_todo_or_branch_name}

## Challenges and Issues

{check_for_fixme_or_todo_comments}
### Open
- {challenge_from_comment}: {current_status}

## Timeline Status

- Original estimate: {extract_from_issue_body_if_available}
- Current projection: {estimate_based_on_velocity}
- Status: {on_track|at_risk|delayed}

---

*Regular progress update. Work continues as planned.*
```

**Interactive Prompts** (if `--interactive`):
```
Q: What percentage complete is this task? [0-100]: 60
Q: What have you accomplished since the last update?: Implemented API endpoints, added unit tests
Q: Are there any blockers or challenges? [y/n]: n
Q: When do you expect to complete this? [date or duration]: 2 days
```

#### Feedback Request Template

**Auto-Fill Fields**:

```markdown
## Request for Review

**Status**: Awaiting Feedback
**Requested by**: {git_user_name}
**Request date**: {current_timestamp}
**Priority**: {auto_determine_priority}

## Context

{extract_from_recent_work}

## Work Completed So Far

{summary_of_commits_and_artifacts}

### Deliverables Ready for Review

{find_completed_artifacts}
- [ ] {deliverable_1} - `{path}` - {description}

## Feedback Requested On

### Critical Decisions
{if_applicable}
1. {extract_from_TODO_comments_or_ADRs}

### Areas Needing Validation
{if_applicable}
- {area_from_FIXME_or_comments}

## Specific Questions

{if_provided_via_interactive_or_content}
1. {question_1}
2. {question_2}

## Timeline Impact

{if_applicable}
- Waiting since: {current_date}
- Impact if delayed: {estimate_based_on_dependencies}

## How to Provide Feedback

1. Review the deliverables listed above
2. Comment on this issue with your feedback
3. Indicate approval or request changes

---

*Awaiting your review to proceed.*
```

**Interactive Prompts** (if `--interactive`):
```
Q: What priority level? [low/medium/high/urgent]: high
Q: What specific areas need feedback?: Architecture decision for data storage
Q: What questions do you have?: Should we use PostgreSQL or MongoDB?
Q: What deliverables are ready?: .aiwg/architecture/sad.md, .aiwg/architecture/adr-001.md
Q: Are there any blockers while waiting? [y/n]: n
```

#### Blocker Notification Template

**Auto-Fill Fields**:

```markdown
## Blocker Alert

**Status**: Blocked
**Reported by**: {git_user_name}
**Reported date**: {current_timestamp}
**Severity**: {critical|high|medium|low}
**Impact**: {project-wide|phase|task|minimal}

## Blocker Description

{blocker_description_from_user_or_interactive}

## Root Cause

{if_known}
{description}

{if_unknown}
Under investigation. Initial observations:
- {observation_from_logs_or_errors}

## Impact Assessment

### Immediate Impact
- Work stopped on: {current_branch_or_task}
- Affects: {related_issues_or_components}

### Downstream Impact
{check_for_dependent_issues}
- Blocks: #{issue_numbers_from_dependencies}
- Timeline impact: {estimate_delay}

### Risk Level
- **Technical Risk**: {assess_based_on_severity}
- **Schedule Risk**: {assess_based_on_timeline}
- **Quality Risk**: {assess_based_on_impact}

## Proposed Solutions

### Option 1: {solution_name}
{from_user_or_interactive}
- **Description**: {description}
- **Effort**: {estimate}
- **Risk**: {assessment}

## Recommended Action

{recommended_solution}

## Work Stopped

{list_affected_work}
- Task: {current_work} - Issue: #{issue_number}

---

**ACTION REQUIRED**: This is a blocking issue requiring immediate attention.
```

**Interactive Prompts** (if `--interactive`):
```
Q: Describe the blocker: External API rate limit reached, blocking integration tests
Q: Severity? [critical/high/medium/low]: high
Q: Impact scope? [project-wide/phase/task/minimal]: phase
Q: Root cause known? [y/n]: y
Q: Root cause description: Third-party API limits to 100 req/hour, need 500+
Q: Proposed solution: Use paid tier or implement request queuing
Q: Recommended action: Upgrade to paid tier ($99/mo)
Q: Does this block other issues? [issue numbers or n]: 18, 19
```

#### Custom Comment

**If `--content` provided**:
```markdown
{content_exactly_as_provided}
```

**If interactive**:
```
Q: Enter your comment (multiline, end with Ctrl+D):
{user_types_content}
```

### Step 5: Review and Confirm

**Show Preview**:

```markdown
## Com