@qazuor/claude-code-config 0.1.0

package/templates/commands/start-feature-plan.md

@@ -0,0 +1,232 @@
+---
+name: start-feature-plan
+description: Initialize comprehensive feature planning following the Four-Phase Workflow
+type: planning
+category: planning
+config_required:
+  planning_path: "Base path for planning sessions (e.g., .claude/sessions/planning)"
+  issue_tracker: "Issue tracking system name (e.g., GitHub, Linear, Jira)"
+  pdr_template: "Path to PDR template file"
+  tech_analysis_template: "Path to technical analysis template"
+  todos_template: "Path to TODOs template file"
+---
+
+# Start Feature Plan Command
+
+Initialize comprehensive planning for a new feature following the Four-Phase Workflow. Creates structured planning session with complete documentation and atomic task breakdown.
+
+## ⚙️ Configuration
+
+| Setting | Description | Example |
+|---------|-------------|---------|
+| `planning_path` | Base directory for planning sessions | `{{PLANNING_PATH}}` |
+| `issue_tracker` | Issue tracking system | `{{ISSUE_TRACKER}}` |
+| `pdr_template` | PDR template location | `{{PDR_TEMPLATE}}` |
+| `tech_analysis_template` | Technical analysis template | `{{TECH_ANALYSIS_TEMPLATE}}` |
+| `todos_template` | TODOs template location | `{{TODOS_TEMPLATE}}` |
+
+## Usage
+
+```bash
+/start-feature-plan {feature_name}
+```
+
+## Agent Delegation Policy
+
+**CRITICAL:** Coordinating agent must ALWAYS delegate to specialized agents using Task tool. Never create planning documents directly.
+
+**Required Agents:**
+
+| Agent | Purpose | Deliverable |
+|-------|---------|-------------|
+| `product-functional` | Requirements analysis | PDR.md |
+| `ui-ux-designer` | Interface design (optional) | Wireframes |
+| `product-technical` | Technical architecture | tech-analysis.md |
+| `product-technical` | Task breakdown | TODOs.md |
+| `tech-lead` | Final review | Approval |
+
+## Execution Flow
+
+### Step 1: Initialize Planning Context
+
+**Duration:** 2-3 minutes
+
+**Process:**
+
+1. Create session directory: `{{PLANNING_PATH}}/{feature_name}/`
+2. Initialize files from templates:
+   - PDR.md
+   - tech-analysis.md
+   - TODOs.md
+   - wireframes/ (if UI-heavy)
+
+### Step 2: Product Requirements (PDR)
+
+**Agent:** `product-functional`
+
+**Deliverable:** Complete PDR.md with:
+
+- Feature overview and objectives
+- Acceptance criteria (AC-001, AC-002, etc.)
+- User stories and personas
+- Business rules and constraints
+- Success metrics
+
+**USER CHECKPOINT:** Must obtain explicit approval before proceeding.
+
+### Step 3: UI/UX Design (Optional)
+
+**Agent:** `ui-ux-designer`
+
+**Deliverable:**
+
+- Wireframes in `wireframes/` directory
+- UI component specifications
+- Interaction flow diagrams
+
+**Note:** Included in PDR approval process.
+
+### Step 4: Technical Analysis
+
+**Agent:** `product-technical`
+
+**Prerequisites:** PDR approved
+
+**Deliverable:** Complete tech-analysis.md with:
+
+- Architecture overview
+- Database schema changes
+- API endpoint design
+- Technology choices justification
+- Risk assessment
+
+**USER CHECKPOINT:** Must obtain explicit approval before proceeding.
+
+### Step 5: Task Breakdown
+
+**Agent:** `product-technical`
+
+**Prerequisites:** Technical analysis approved
+
+**Process:**
+
+1. Break down into atomic tasks (1-2 hours each)
+2. Identify dependencies
+3. Prioritize implementation order
+4. Estimate effort and complexity
+
+**Deliverable:** Complete TODOs.md with prioritized task list.
+
+### Step 6: Final Review
+
+**Agent:** `tech-lead`
+
+**Process:** Review all artifacts and approve planning phase.
+
+## Planning Session Structure
+
+```text
+{{PLANNING_PATH}}/{feature_name}/
+├── PDR.md
+├── tech-analysis.md
+├── TODOs.md
+├── wireframes/
+└── notes/
+```
+
+## Quality Standards
+
+### PDR Requirements
+
+- Clear objectives and value proposition
+- Specific, testable acceptance criteria
+- Complete user stories with personas
+- Edge cases and constraints documented
+- Measurable success metrics
+
+### Technical Analysis Requirements
+
+- Architecture alignment with existing patterns
+- Proper database design
+- Type-safe API design
+- Risk assessment with mitigation
+- Technology choices justified
+
+### Task Breakdown Requirements
+
+- All tasks atomic (1-2 hours max)
+- Clear dependencies mapped
+- Testable completion criteria
+- Priority ordering defined
+- Realistic effort estimates
+
+## Output Format
+
+```text
+✅ FEATURE PLANNING COMPLETE
+
+Feature: {feature_name}
+Planning Session: {{PLANNING_PATH}}/{feature_name}/
+
+Documents Created:
+✅ PDR.md - {n} acceptance criteria
+✅ tech-analysis.md - Architecture complete
+✅ TODOs.md - {n} atomic tasks
+
+Planning Summary:
+- Estimated Effort: {hours}
+- Implementation Phases: {n}
+- Critical Dependencies: {n}
+- Risk Level: {level}
+
+Ready for Phase 2: Implementation
+```
+
+## Critical Checkpoints
+
+| Checkpoint | Agent | User Approval | Blocks Next Step |
+|------------|-------|---------------|------------------|
+| PDR Complete | product-functional | REQUIRED | Tech Analysis |
+| Tech Analysis Complete | product-technical | REQUIRED | Task Breakdown |
+| TODOs Complete | product-technical | OPTIONAL | Implementation |
+
+## Common Patterns
+
+### Database-Heavy Features
+
+- Schema design first
+- Migration strategy defined
+- Performance considerations documented
+
+### API-Heavy Features
+
+- Endpoint design prioritized
+- Authentication requirements clarified
+- Documentation strategy defined
+
+### UI-Heavy Features
+
+- Component hierarchy designed
+- State management planned
+- Accessibility requirements documented
+
+## Related Commands
+
+- `/start-refactor-plan` - Planning for refactoring
+- `/quality-check` - Validation before implementation
+- `/sync-planning` - Sync to issue tracker
+
+## When to Use
+
+- **Required:** Before implementing new features
+- **Required:** When starting significant functionality
+- **Optional:** For complex bug fixes requiring architecture changes
+- **Recommended:** When multiple developers will collaborate
+
+## Post-Command Actions
+
+1. Present planning artifacts to user
+2. Wait for explicit approval at each checkpoint
+3. Iterate based on feedback
+4. Offer to sync to {{ISSUE_TRACKER}} after final approval
+5. Begin Phase 2 implementation only after user confirmation

package/templates/commands/start-refactor-plan.md

@@ -0,0 +1,244 @@
+---
+name: start-refactor-plan
+description: Plan comprehensive refactoring with risk assessment and incremental steps
+type: planning
+category: planning
+config_required:
+  refactor_path: "Base path for refactor sessions (e.g., .claude/sessions/refactor)"
+  test_coverage_min: "Minimum test coverage percentage (e.g., 90)"
+  issue_tracker: "Issue tracking system name"
+---
+
+# Start Refactor Plan Command
+
+Plan comprehensive refactoring work safely with risk assessment, incremental steps, and test validation strategy.
+
+## ⚙️ Configuration
+
+| Setting | Description | Example |
+|---------|-------------|---------|
+| `refactor_path` | Base directory for refactor sessions | `{{REFACTOR_PATH}}` |
+| `test_coverage_min` | Minimum test coverage required | `{{TEST_COVERAGE_MIN}}%` |
+| `issue_tracker` | Issue tracking system | `{{ISSUE_TRACKER}}` |
+
+## Usage
+
+```bash
+/start-refactor-plan {refactor_scope}
+```
+
+## Execution Flow
+
+### Step 1: Current Code Analysis
+
+**Agent:** `debugger`
+
+**Deliverable:** Current state analysis with:
+
+- Code smells and technical debt
+- Architecture and dependency mapping
+- Existing behavior documentation
+- Potential breaking points
+
+**Analysis Areas:**
+
+| Area | Focus |
+|------|-------|
+| Code Quality | Complexity, maintainability |
+| Performance | Bottlenecks, inefficiencies |
+| Security | Vulnerabilities, exposures |
+| Architecture | Pattern violations, inconsistencies |
+| Testing | Coverage gaps, test quality |
+
+### Step 2: Architecture Validation
+
+**Agent:** `architecture-validator`
+
+**Deliverable:** Architecture assessment with:
+
+- Pattern compliance review
+- Layering violations
+- Dependency management issues
+- SOLID principles adherence
+
+### Step 3: Refactor Strategy
+
+**Agent:** `product-technical`
+
+**Deliverable:** Complete strategy document with:
+
+- Refactoring objectives and success criteria
+- Safe refactoring boundaries
+- Backwards compatibility strategy
+- Rollback procedures
+
+### Step 4: Incremental Steps
+
+**Agent:** `product-technical`
+
+**Requirements:** Each step must:
+
+- Be ≤ 2 hours of work
+- Preserve functionality
+- Pass all tests
+- Allow rollback
+- Have clear validation criteria
+
+**Deliverable:** Step-by-step plan with validation points.
+
+### Step 5: Test Strategy
+
+**Agent:** `qa-engineer` with `web-app-testing` skill
+
+**Deliverable:** Testing strategy with:
+
+- Pre-refactor baseline
+- Step-by-step validation plan
+- Regression test enhancements
+- Performance benchmarks
+
+### Step 6: Risk Assessment
+
+**Agent:** `tech-lead`
+
+**Deliverable:** Risk assessment and approval covering:
+
+- Business continuity impact
+- Technical complexity
+- Resource requirements
+- Timeline feasibility
+- Rollback strategy validation
+
+## Refactor Session Structure
+
+```text
+{{REFACTOR_PATH}}/{refactor_scope}/
+├── current-analysis.md
+├── architecture-issues.md
+├── refactor-strategy.md
+├── refactor-steps.md
+├── test-strategy.md
+├── risk-assessment.md
+└── checkpoints/
+```
+
+## Quality Standards
+
+### Analysis Requirements
+
+- Comprehensive coverage of all code in scope
+- Issues categorized by type and severity
+- All dependencies mapped
+- Current behavior documented
+- Risk points identified
+
+### Planning Requirements
+
+- Atomic steps (≤ 2 hours each)
+- Test validation for every step
+- Clear rollback strategy
+- Dependency-aware ordering
+- Risk mitigation for each risk
+
+### Safety Requirements
+
+- No breaking changes for users
+- No performance degradation
+- ≥ {{TEST_COVERAGE_MIN}}% coverage maintained
+- All steps pass CI/CD
+- All changes documented
+
+## Output Format
+
+```text
+✅ REFACTOR PLANNING COMPLETE
+
+Refactor Scope: {refactor_scope}
+Planning Session: {{REFACTOR_PATH}}/{refactor_scope}/
+
+Analysis Summary:
+- Files Analyzed: {n}
+- Issues Identified: {n} (high/medium/low)
+- Architecture Violations: {n}
+- Test Coverage Gaps: {n}%
+
+Refactor Plan:
+- Total Steps: {n} atomic steps
+- Estimated Duration: {hours}
+- Checkpoints: {n} validation points
+- Risk Level: {level}
+
+Test Strategy:
+- Tests to Add: {n}
+- Regression Tests: {n} enhanced
+- Performance Tests: {n} benchmarks
+
+Ready for safe, incremental refactoring
+```
+
+## Refactor Categories
+
+### Architecture Refactoring
+
+**Patterns:**
+
+- Layer separation improvements
+- Dependency injection
+- Interface abstraction
+- Error handling standardization
+
+**Safety:** Gradual migration, adapter patterns, step-by-step updates
+
+### Performance Refactoring
+
+**Patterns:**
+
+- Database optimization
+- Caching implementation
+- Algorithm efficiency
+- Memory optimization
+
+**Safety:** Performance benchmarks, load testing, automatic rollback
+
+### Code Quality Refactoring
+
+**Patterns:**
+
+- Code smell elimination
+- Technical debt reduction
+- Test coverage improvements
+- Documentation enhancement
+
+**Safety:** Behavior preservation testing, regression validation
+
+## Step Validation
+
+All steps must pass:
+
+| Validation Type | Criteria |
+|----------------|----------|
+| Functional | Tests pass, no regressions, API contracts maintained |
+| Performance | Response times maintained, memory acceptable, queries stable |
+| Quality | ≥{{TEST_COVERAGE_MIN}}% coverage, linting passes, patterns followed |
+
+## Related Commands
+
+- `/start-feature-plan` - Planning for new features
+- `/quality-check` - Validation after steps
+- `/review-code` - Code quality analysis
+- `/review-performance` - Performance assessment
+
+## When to Use
+
+- **Required:** Before major architectural changes
+- **Required:** When technical debt impacts development
+- **Recommended:** Before performance optimization
+- **Required:** When refactoring affects multiple packages
+
+## Post-Command Actions
+
+1. Review refactor plan with user
+2. Ensure team alignment on scope
+3. Set up monitoring and rollback mechanisms
+4. Execute step-by-step with validation after each
+5. Offer to sync to {{ISSUE_TRACKER}}

package/templates/commands/sync-planning.md

@@ -0,0 +1,176 @@
+---
+name: sync-planning
+description: Synchronize planning session to issue tracker
+type: planning
+category: planning
+config_required:
+  issue_tracker: "Issue tracking system (e.g., GitHub, Linear, Jira)"
+  issue_tracker_token_env: "Environment variable for auth token"
+  issue_tracker_owner_env: "Environment variable for owner/org"
+  issue_tracker_repo_env: "Environment variable for repository"
+  planning_path: "Base path for planning sessions"
+  tracking_file: "Path to tracking data file"
+---
+
+# Sync Planning to Issue Tracker
+
+Synchronize planning session to issue tracker, creating parent and sub-issues for all tasks.
+
+## ⚙️ Configuration
+
+| Setting | Description | Example |
+|---------|-------------|---------|
+| `issue_tracker` | Issue tracking system | `{{ISSUE_TRACKER}}` |
+| `issue_tracker_token_env` | Auth token environment variable | `{{ISSUE_TRACKER_TOKEN}}` |
+| `issue_tracker_owner_env` | Owner/org environment variable | `{{ISSUE_TRACKER_OWNER}}` |
+| `issue_tracker_repo_env` | Repository environment variable | `{{ISSUE_TRACKER_REPO}}` |
+| `planning_path` | Planning sessions directory | `{{PLANNING_PATH}}` |
+| `tracking_file` | Tracking data file path | `{{TRACKING_FILE}}` |
+
+## Usage
+
+```bash
+/sync-planning [session_path]
+```
+
+## When to Use
+
+- After completing planning phase and getting approval
+- To create trackable issues for feature planning
+- When working across multiple devices
+- Before starting implementation
+
+## Process
+
+### Step 1: Identify Session
+
+Ask user which planning session to sync if not obvious from context.
+
+Auto-detect if currently in planning directory.
+
+**Expected path:** `{{PLANNING_PATH}}/{session-name}/`
+
+### Step 2: Verify Required Files
+
+Check that files exist:
+
+- PDR.md (Product Requirements)
+- TODOs.md (Task breakdown)
+
+If missing, inform user and stop.
+
+### Step 3: Get Configuration
+
+Required environment variables:
+
+- `{{ISSUE_TRACKER_TOKEN}}` - Authentication token
+- `{{ISSUE_TRACKER_OWNER}}` - Owner/organization
+- `{{ISSUE_TRACKER_REPO}}` - Repository name
+
+If not available, ask user to provide them.
+
+### Step 4: Execute Sync
+
+Synchronize to {{ISSUE_TRACKER}}:
+
+- Create parent issue for feature
+- Create sub-issues for all tasks
+- Update existing issues (idempotent)
+- Enrich with planning context
+
+### Step 5: Report Results
+
+```text
+✅ Planning synced to {{ISSUE_TRACKER}} successfully!
+
+Parent Issue: {title}
+   URL: {url}
+   Number: #{number}
+
+Statistics:
+   • {n} tasks created
+   • {n} tasks updated
+   • {n} tasks skipped
+   • {n} failures
+
+Next Steps:
+   1. TODOs.md updated with issue links
+   2. Commit changes (TODOs.md, {{TRACKING_FILE}})
+   3. View issues in {{ISSUE_TRACKER}}
+   4. Use /check-completed after task completion
+```
+
+### Step 6: Update TODOs.md
+
+Automatically adds issue links to tasks:
+
+```markdown
+### T-003-012: Task name
+
+**Status:** [ ] Pending
+**Issue:** [#{number}]({url})
+```
+
+### Step 7: Suggest Next Actions
+
+1. Commit changes to TODOs.md and {{TRACKING_FILE}}
+2. Push to remote
+3. View issues in {{ISSUE_TRACKER}}
+4. Update status with /check-completed
+
+## Error Handling
+
+| Error | Solution |
+|-------|----------|
+| Missing config | Set environment variables |
+| Files not found | Complete planning first with /start-feature-plan |
+| API errors | Verify token, permissions, rate limits |
+| Duplicates | Sync updates existing issues safely |
+
+## Advanced Options
+
+### Dry Run Mode
+
+Preview changes without creating issues:
+
+```typescript
+{
+  dryRun: true
+}
+```
+
+### Custom Tracking Path
+
+Use custom location for tracking data:
+
+```typescript
+{
+  trackingPath: '.custom-tracking/data.json'
+}
+```
+
+### Skip Existing
+
+Only create new issues, don't update:
+
+```typescript
+{
+  updateExisting: false
+}
+```
+
+## Important Notes
+
+- **Idempotent:** Safe to run multiple times - updates, not duplicates
+- **Tracking:** {{TRACKING_FILE}} stores mapping between tasks and issues
+- **Commit tracking:** Always commit tracking file for cross-device sync
+- **Status sync:** Task status determines issue state (open/closed)
+- **Enrichment:** Issues enriched with planning context
+- **Labels:** Auto-generated based on task type and priority
+
+## Related Commands
+
+- `/start-feature-plan` - Create planning session
+- `/check-completed` - Auto-close completed tasks
+- `/sync-todos` - Sync code TODO comments
+- `/cleanup-issues` - Clean up stale issues