claude-code-templates 1.21.4 → 1.21.6

package/components/commands/team/estimate-assistant.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Bash, Glob, Grep
+argument-hint: [task-description] | --historical | --complexity-analysis | --team-velocity | --confidence-intervals
+description: Generate accurate task estimates using historical data, complexity analysis, and team velocity metrics
+model: sonnet
+---
+
+# Estimate Assistant
+
+Generate data-driven task estimates with confidence intervals and accuracy tracking: **$ARGUMENTS**
+
+## Current Estimation Context
+
+- Team velocity: !`git log --oneline --since='1 month ago' | wc -l` commits in last month
+- Historical data: Git history analysis for similar task completion patterns
+- Code complexity: !`find . -name "*.js" -o -name "*.ts" -o -name "*.py" | head -5 | xargs wc -l 2>/dev/null | tail -1 || echo "No code files"`
+- Sprint tracking: Linear task completion times and estimate accuracy
+
+## Task
+
+Execute comprehensive task estimation with historical analysis and confidence modeling:
+
+**Estimation Focus**: Use $ARGUMENTS for task description analysis, historical pattern matching, complexity assessment, or team velocity calculation
+
+**Estimation Framework**:
+1. **Historical Pattern Analysis** - Analyze similar past tasks, extract completion time patterns, identify velocity trends, calculate accuracy metrics
+2. **Complexity Assessment** - Evaluate technical complexity, assess scope uncertainty, identify risk factors, estimate effort distribution
+3. **Team Velocity Integration** - Calculate sprint velocity, analyze individual capacity, assess team expertise, factor in availability constraints
+4. **Confidence Modeling** - Generate confidence intervals, assess estimation uncertainty, identify risk factors, provide accuracy ranges
+5. **Calibration Analysis** - Compare past estimates vs actuals, identify systematic biases, calculate estimation accuracy, improve prediction models
+6. **Context Integration** - Factor in current sprint load, assess team familiarity, evaluate external dependencies, integrate deadline pressure
+
+**Advanced Features**: Multi-point estimation, Monte Carlo simulation, reference class forecasting, estimation accuracy tracking, bias correction algorithms.
+
+**Quality Metrics**: Estimation confidence levels, accuracy historical trends, velocity stability, complexity correlation analysis.
+
+**Output**: Data-driven estimates with confidence intervals, historical accuracy metrics, risk assessment, and calibration recommendations.

package/components/commands/team/issue-triage.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Bash
+argument-hint: [scope] | --github-issues | --linear-tasks | --priority-analysis | --team-assignment
+description: Intelligent issue triage with automatic categorization, prioritization, and team assignment
+model: sonnet
+---
+
+# Issue Triage
+
+Intelligently triage and prioritize issues with automated routing and team assignment: **$ARGUMENTS**
+
+## Current Triage Context
+
+- Repository: !`gh repo view --json nameWithOwner -q .nameWithOwner 2>/dev/null || echo "No repo context"`
+- Open issues: !`gh issue list --state open --limit 1 --json number | jq length 2>/dev/null || echo "Check manually"`
+- Linear teams: Available Linear teams and project assignments for routing
+- Triage backlog: Current volume and age of untriaged issues
+
+## Task
+
+Execute intelligent issue analysis with automated triage and priority assignment:
+
+**Triage Scope**: Use $ARGUMENTS to focus on GitHub issues, Linear tasks, priority analysis, or team assignment optimization
+
+**Triage Framework**:
+1. **Issue Analysis** - Extract issue metadata, analyze content patterns, assess severity indicators, evaluate impact scope
+2. **Category Classification** - Identify issue type (bug, feature, documentation), assess complexity level, determine urgency factors
+3. **Priority Assessment** - Calculate priority score using severity, impact, effort, and business value metrics
+4. **Team Routing** - Match issue skills to team expertise, balance workload distribution, consider current sprint capacity
+5. **Label Management** - Apply consistent labeling scheme, maintain taxonomy standards, enable filtering and reporting
+6. **SLA Assignment** - Set response time expectations, establish resolution targets, track performance metrics
+
+**Advanced Features**: Automated severity detection, intelligent team matching, workload balancing, SLA monitoring, escalation workflows.
+
+**Quality Assurance**: Consistency validation, triage accuracy tracking, team satisfaction monitoring, process optimization feedback.
+
+**Output**: Complete issue triage with priority assignments, team routing recommendations, SLA targets, and process improvement insights.

package/components/commands/team/memory-spring-cleaning.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Glob
+argument-hint: [scope] | --claude-md | --documentation | --outdated-patterns | --implementation-sync
+description: Clean and organize project memory files with implementation synchronization and pattern updates
+model: sonnet
+---
+
+# Memory Spring Cleaning
+
+Clean and synchronize project memory with current implementation patterns: **$ARGUMENTS**
+
+## Current Memory Context
+
+- Memory files: !`find . -name "CLAUDE*.md" | wc -l` CLAUDE.md files in project
+- Documentation: !`find . -name "README*" -o -name "*.md" | wc -l` total documentation files
+- Last update: !`find . -name "CLAUDE.md" -exec stat -c "%y" {} \; 2>/dev/null | head -1 || echo "No CLAUDE.md found"`
+- Implementation drift: Analysis of documented vs actual patterns
+
+## Task
+
+Execute comprehensive memory cleanup with implementation synchronization:
+
+**Cleanup Scope**: Use $ARGUMENTS to focus on CLAUDE.md files, general documentation, outdated pattern identification, or implementation synchronization
+
+**Memory Cleaning Framework**:
+1. **Memory File Discovery** - Locate all CLAUDE.md and documentation files, assess hierarchy and organization, identify redundant content
+2. **Implementation Analysis** - Compare documented patterns with actual code, identify implementation drift, assess accuracy gaps
+3. **Pattern Validation** - Verify documented conventions, validate code examples, check dependency accuracy, assess technology stack alignment
+4. **Content Optimization** - Remove outdated information, consolidate duplicate content, improve organization structure, enhance clarity
+5. **Synchronization Updates** - Update development commands, refresh technology stack references, sync architectural patterns, validate workflows
+6. **Quality Assurance** - Ensure consistency across files, validate markdown formatting, check link integrity, maintain version alignment
+
+**Advanced Features**: Automated pattern detection, implementation drift analysis, cross-reference validation, documentation health scoring.
+
+**Memory Health**: Content freshness metrics, accuracy validation, usage pattern analysis, maintenance scheduling recommendations.
+
+**Output**: Cleaned and synchronized memory files with updated patterns, validated implementations, and maintenance recommendations.

package/components/commands/team/migration-assistant.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [action] | --plan | --analyze | --migrate | --verify | --rollback
+description: Comprehensive system migration assistance with planning, analysis, execution, and rollback capabilities
+model: sonnet
+---
+
+# Migration Assistant
+
+Execute comprehensive system migrations with planning, verification, and rollback capabilities: **$ARGUMENTS**
+
+## Current Migration Context
+
+- Source systems: GitHub CLI authentication and API access status
+- Target systems: Linear MCP server connectivity and permissions
+- Backup storage: Available storage space and backup verification
+- Migration scope: Data volume estimation and complexity assessment
+
+## Task
+
+Execute systematic migration process with comprehensive safety measures and validation:
+
+**Migration Action**: Use $ARGUMENTS to specify migration planning, analysis, execution, verification, or rollback operations
+
+**Migration Framework**:
+1. **Prerequisites Validation** - Verify GitHub CLI authentication, confirm Linear MCP connectivity, validate permissions, ensure backup storage
+2. **Migration Planning** - Assess data volume and complexity, design migration strategy, identify dependencies, create rollback plan
+3. **Risk Analysis** - Evaluate potential failure points, assess data integrity risks, identify system dependencies, plan contingency measures
+4. **Execution Management** - Implement migration phases, monitor progress and health, handle errors gracefully, maintain audit trails
+5. **Verification Process** - Validate data integrity, confirm system functionality, test user workflows, verify performance metrics
+6. **Rollback Procedures** - Implement safe rollback mechanisms, restore system state, validate recovery, communicate status updates
+
+**Advanced Features**: Incremental migration support, real-time progress monitoring, automated health checks, comprehensive logging, emergency stop mechanisms.
+
+**Safety Measures**: Multi-point backups, integrity validation, rollback testing, system health monitoring, stakeholder communication.
+
+**Output**: Complete migration execution with progress tracking, validation reports, rollback readiness, and post-migration optimization recommendations.

package/components/commands/team/retrospective-analyzer.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Bash, Glob
+argument-hint: [sprint-identifier] | --metrics | --insights | --action-items | --trends
+description: Analyze team retrospectives with quantitative metrics and actionable insights generation
+model: sonnet
+---
+
+# Retrospective Analyzer
+
+Analyze team retrospectives with comprehensive metrics and actionable improvement insights: **$ARGUMENTS**
+
+## Current Retrospective Context
+
+- Sprint period: !`git log --oneline --since='2 weeks ago' | wc -l` commits in recent sprint
+- Team activity: Analysis of recent collaboration patterns and productivity metrics
+- Linear sprint: Current sprint data and completion metrics from Linear MCP
+- Previous retrospectives: Historical retrospective data and improvement tracking
+
+## Task
+
+Execute comprehensive retrospective analysis with quantitative insights and improvement recommendations:
+
+**Analysis Focus**: Use $ARGUMENTS to specify sprint identifier, quantitative metrics, insight generation, action item tracking, or trend analysis
+
+**Retrospective Analysis Framework**:
+1. **Sprint Performance Analysis** - Analyze velocity trends, completion rates, cycle time metrics, quality indicators
+2. **Team Collaboration Assessment** - Evaluate communication patterns, code review effectiveness, knowledge sharing, pair programming impact
+3. **Process Effectiveness** - Assess meeting efficiency, planning accuracy, impediment resolution, workflow optimization
+4. **Quality Metrics** - Analyze bug rates, technical debt accumulation, code review quality, testing effectiveness
+5. **Individual Contribution** - Evaluate workload distribution, skill development, mentorship activities, cross-training progress
+6. **Actionable Insights Generation** - Identify improvement opportunities, prioritize action items, track progress, measure impact
+
+**Advanced Features**: Trend analysis across multiple sprints, predictive performance modeling, team satisfaction correlation, continuous improvement tracking.
+
+**Insight Quality**: Data-driven recommendations, quantified improvement potential, implementation feasibility, success measurement criteria.
+
+**Output**: Comprehensive retrospective analysis with quantitative metrics, actionable insights, prioritized improvements, and progress tracking framework.

package/components/commands/team/session-learning-capture.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Glob
+argument-hint: [capture-type] | --project-learnings | --implementation-corrections | --structure-insights | --workflow-improvements
+description: Capture and document session learnings with automatic knowledge integration and memory updates
+model: sonnet
+---
+
+# Session Learning Capture
+
+Capture and integrate session learnings into project memory and knowledge base: **$ARGUMENTS**
+
+## Current Learning Context
+
+- Session duration: Current Claude Code session learning opportunities
+- Memory files: !`find . -name "CLAUDE*.md" | wc -l` available memory files for knowledge integration
+- Project complexity: Assessment of project structure and documentation completeness
+- Learning patterns: Identification of knowledge gaps and correction opportunities
+
+## Task
+
+Execute comprehensive learning capture with automatic knowledge integration:
+
+**Capture Type**: Use $ARGUMENTS to focus on project learnings, implementation corrections, structure insights, or workflow improvements
+
+**Learning Capture Framework**:
+1. **Learning Identification** - Detect new project knowledge, identify implementation corrections, recognize structural insights, note workflow discoveries
+2. **Knowledge Classification** - Categorize learning type, assess importance level, determine integration location, evaluate reusability potential
+3. **Context Analysis** - Analyze session context, identify triggering conditions, assess knowledge applicability, determine documentation needs
+4. **Integration Planning** - Select appropriate memory files, determine update strategy, maintain consistency, preserve existing knowledge
+5. **Memory Updates** - Update CLAUDE.md files, enhance documentation, improve workflows, strengthen knowledge base
+6. **Validation Process** - Verify accuracy of captured knowledge, ensure integration quality, validate accessibility, confirm usefulness
+
+**Advanced Features**: Automated learning detection, intelligent categorization, context-aware integration, knowledge graph enhancement, version control integration.
+
+**Quality Assurance**: Learning accuracy validation, integration consistency, accessibility optimization, knowledge retrieval efficiency.
+
+**Output**: Comprehensive learning integration with updated memory files, enhanced documentation, improved workflows, and validated knowledge base.

package/components/commands/team/sprint-planning.md

@@ -0,0 +1,189 @@
+---
+allowed-tools: Read, WebSearch
+argument-hint: [sprint-duration] | [start-date] [duration]
+description: Plan and organize sprint workflows with Linear integration and capacity analysis
+model: sonnet
+---
+
+# Sprint Planning
+
+Plan and organize sprint: $ARGUMENTS
+
+## Current Sprint Context
+
+- Current sprint: Check Linear or GitHub milestones
+- Team velocity: Analyze recent sprint performance
+- Open issues: !`gh issue list --limit 10 --state open` (if GitHub CLI available)
+- Project structure: @README.md or @.github/ (if exists)
+
+## Instructions
+
+1. **Check Linear Integration**
+First, verify if the Linear MCP server is connected:
+- If connected: Proceed with full integration
+- If not connected: Ask user to install Linear MCP server from https://github.com/modelcontextprotocol/servers
+- Fallback: Use GitHub issues and manual input
+
+2. **Gather Sprint Context**
+Collect the following information:
+- Sprint duration (e.g., 2 weeks)
+- Sprint start date
+- Team members involved
+- Sprint goals/themes
+- Previous sprint velocity (if available)
+
+3. **Analyze Current State**
+
+#### With Linear Connected:
+```
+1. Fetch all backlog items from Linear
+2. Get in-progress tasks and their status
+3. Analyze task priorities and dependencies
+4. Check team member assignments and capacity
+5. Review blocked tasks and impediments
+```
+
+#### Without Linear (Fallback):
+```
+1. Analyze GitHub issues by labels and milestones
+2. Review open pull requests and their status
+3. Check recent commit activity
+4. Ask user for additional context about tasks
+```
+
+4. **Sprint Planning Analysis**
+
+Generate a comprehensive sprint plan including:
+
+```markdown
+# Sprint Planning Report - [Sprint Name]
+
+## Sprint Overview
+- Duration: [Start Date] to [End Date]
+- Team Members: [List]
+- Sprint Goal: [Description]
+
+## Capacity Analysis
+- Total Available Hours: [Calculation]
+- Previous Sprint Velocity: [Points/Hours]
+- Recommended Capacity: [80-85% of total]
+
+## Proposed Sprint Backlog
+
+### High Priority Tasks
+1. [Task ID] - [Title]
+   - Estimate: [Points/Hours]
+   - Assignee: [Name]
+   - Dependencies: [List]
+   - Acceptance Criteria: [Details]
+
+### Medium Priority Tasks
+[Similar format]
+
+### Nice-to-Have Tasks
+[Similar format]
+
+## Risk Assessment
+- Technical Risks: [List]
+- Resource Risks: [List]
+- Dependency Risks: [List]
+
+## Recommendations
+1. [Specific recommendations based on analysis]
+2. [Resource allocation suggestions]
+3. [Risk mitigation strategies]
+
+## Metrics to Track
+- Velocity
+- Burndown rate
+- Blocked time
+- Cycle time
+```
+
+5. **Interactive Planning Session**
+
+Offer to help with:
+1. Task breakdown and estimation
+2. Dependency mapping
+3. Resource balancing
+4. Risk mitigation planning
+5. Sprint backlog finalization
+
+## Error Handling
+
+### Linear Connection Issues
+```
+"I notice the Linear MCP server is not connected. To get the most value from sprint planning:
+
+1. Install the Linear MCP server:
+   npm install -g @modelcontextprotocol/server-linear
+
+2. Configure with your Linear API key
+3. Restart this session with Linear connected
+
+For now, I'll proceed using GitHub data and manual input."
+```
+
+### Missing Data
+```
+"I need more information to create an effective sprint plan:
+- [List specific missing data]
+- [Provide templates for manual input]
+```
+
+## Example Usage
+
+### User Input:
+"Help me plan our next 2-week sprint starting Monday"
+
+### Assistant Response:
+```
+I'll help you plan your sprint. Let me first check your Linear integration...
+
+[If connected]: Great! I can see your Linear workspace. Let me analyze your backlog...
+
+[Analysis results]
+
+Based on my analysis, here's your proposed sprint plan:
+
+**Sprint 24-01 (Jan 8-19)**
+
+**Recommended Scope (32 story points):**
+1. ENG-123: Implement user authentication (8 pts) - John
+2. ENG-124: Database migration scripts (5 pts) - Sarah
+3. ENG-125: API rate limiting (5 pts) - Mike
+...
+
+**Key Risks:**
+- ENG-123 blocks 3 other tasks
+- Sarah has 20% allocation to support
+
+Would you like me to:
+1. Adjust the scope based on different priorities?
+2. Create a dependency visualization?
+3. Generate sprint planning meeting agenda?
+```
+
+## Best Practices
+
+1. **Always verify capacity**: Don't overcommit the team
+2. **Include buffer time**: Plan for 80-85% capacity
+3. **Consider dependencies**: Map task relationships
+4. **Balance workload**: Distribute tasks evenly
+5. **Define clear goals**: Ensure sprint has focused objectives
+6. **Plan for unknowns**: Include spike/investigation time
+
+## Integration Points
+
+- Linear: Task management and tracking
+- GitHub: Code repository and PRs
+- Slack: Team communication (if MCP available)
+- Calendar: Team availability (if accessible)
+
+## Output Formats
+
+Offer multiple output options:
+1. Markdown report (default)
+2. CSV for spreadsheet import
+3. JSON for automation tools
+4. Linear-compatible format for direct import

package/components/commands/team/standup-report.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Bash, Glob, Grep
+argument-hint: [time-range] | --yesterday | --last-24h | --since-friday | --custom-range
+description: Generate comprehensive daily standup reports with team activity analysis and progress tracking
+model: sonnet
+---
+
+# Standup Report
+
+Generate comprehensive daily standup reports with team activity and progress analysis: **$ARGUMENTS**
+
+## Current Standup Context
+
+- Linear connection: Linear MCP server status and task synchronization
+- Time range: !`date -d 'yesterday' '+%Y-%m-%d'` to !`date '+%Y-%m-%d'` analysis period
+- Team members: !`git log --format='%ae' --since='1 day ago' | sort -u | wc -l` active contributors
+- Repository: !`gh repo view --json nameWithOwner -q .nameWithOwner 2>/dev/null || echo "No repo context"`
+
+## Task
+
+Generate comprehensive standup report with team activity analysis and progress insights:
+
+**Time Range**: Use $ARGUMENTS to specify yesterday, last 24 hours, since Friday, or custom date range for analysis
+
+**Standup Report Framework**:
+1. **Git Activity Analysis** - Extract commit activity, analyze code changes, identify contributors, assess impact scope
+2. **Linear Task Progress** - Query task updates, analyze completion status, track sprint progress, identify blockers
+3. **Pull Request Activity** - Review PR submissions, analyze review activity, track merge status, assess collaboration patterns
+4. **Team Collaboration** - Analyze pair programming, code review participation, knowledge sharing, mentorship activities
+5. **Progress Tracking** - Calculate velocity metrics, assess goal completion, identify trends, predict sprint outcomes
+6. **Blockers & Impediments** - Identify stuck tasks, analyze delay patterns, assess resource needs, recommend solutions
+
+**Advanced Features**: Automated activity categorization, progress visualization, trend analysis, predictive insights, team health scoring.
+
+**Report Quality**: Actionable insights, clear progress indicators, obstacle identification, team coordination support, meeting efficiency optimization.
+
+**Output**: Comprehensive standup report with team activity summary, progress metrics, blocker identification, and actionable next steps.

package/components/commands/team/team-knowledge-mapper.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Bash, Glob, Grep
+argument-hint: [mapping-type] | --skill-matrix | --knowledge-gaps | --expertise-areas | --learning-paths
+description: Map team knowledge and expertise with skill gap analysis and learning path recommendations
+model: sonnet
+---
+
+# Team Knowledge Mapper
+
+Map team knowledge and expertise with comprehensive skill gap analysis: **$ARGUMENTS**
+
+## Current Knowledge Context
+
+- Team expertise: !`git log --format='%ae' --since='3 months ago' | sort | uniq -c | sort -nr` contributor activity patterns
+- Technology stack: Analysis of languages, frameworks, and tools used in codebase
+- Knowledge distribution: Assessment of expertise concentration and bus factor risks
+- Learning activity: Recent skill development and cross-training initiatives
+
+## Task
+
+Execute comprehensive knowledge mapping with skill gap analysis and learning optimization:
+
+**Mapping Type**: Use $ARGUMENTS to focus on skill matrix creation, knowledge gap identification, expertise area analysis, or learning path recommendations
+
+**Knowledge Mapping Framework**:
+1. **Skill Matrix Creation** - Map individual expertise levels, identify core competencies, assess technology proficiencies, evaluate domain knowledge
+2. **Knowledge Gap Analysis** - Identify critical skill gaps, assess team vulnerabilities, evaluate learning priorities, recommend skill development
+3. **Expertise Distribution** - Analyze knowledge concentration, identify single points of failure, assess bus factor risks, recommend knowledge sharing
+4. **Learning Path Planning** - Design skill development roadmaps, recommend training priorities, plan mentorship programs, optimize knowledge transfer
+5. **Cross-Training Optimization** - Identify pairing opportunities, plan knowledge rotation, design shadowing programs, optimize skill redundancy
+6. **Knowledge Retention** - Assess knowledge preservation, plan documentation strategies, design knowledge capture systems, prevent expertise loss
+
+**Advanced Features**: Dynamic skill tracking, expertise prediction modeling, learning ROI analysis, knowledge graph visualization, competency gap forecasting.
+
+**Strategic Planning**: Succession planning support, hiring decision guidance, team composition optimization, skill portfolio balancing.
+
+**Output**: Comprehensive knowledge map with skill matrices, gap analysis, learning recommendations, and strategic knowledge management plans.

package/components/commands/team/team-velocity-tracker.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Bash, Glob, Grep
+argument-hint: [analysis-period] | --sprint | --monthly | --quarterly | --trend-analysis
+description: Track and analyze team velocity with predictive forecasting and performance optimization recommendations
+model: sonnet
+---
+
+# Team Velocity Tracker
+
+Track team velocity patterns with predictive forecasting and performance optimization: **$ARGUMENTS**
+
+## Current Velocity Context
+
+- Sprint velocity: !`git log --oneline --since='2 weeks ago' | wc -l` commits per current sprint
+- Team consistency: Analysis of velocity stability across recent sprints
+- Linear tracking: Sprint point completion rates and story delivery metrics
+- Capacity factors: Team size changes, availability, and skill development impact
+
+## Task
+
+Execute comprehensive velocity tracking with predictive analytics and optimization recommendations:
+
+**Analysis Period**: Use $ARGUMENTS to focus on sprint velocity, monthly trends, quarterly patterns, or comprehensive trend analysis
+
+**Velocity Tracking Framework**:
+1. **Historical Velocity Analysis** - Extract sprint completion data, analyze story point delivery, calculate team throughput, identify performance patterns
+2. **Consistency Assessment** - Measure velocity stability, identify variance patterns, assess predictability factors, evaluate planning accuracy
+3. **Capacity Correlation** - Analyze team size impact, assess skill level effects, evaluate availability constraints, measure external factor influence
+4. **Predictive Forecasting** - Generate velocity projections, predict sprint outcomes, estimate delivery timelines, calculate confidence intervals
+5. **Performance Optimization** - Identify improvement opportunities, recommend capacity adjustments, suggest process enhancements, optimize team composition
+6. **Quality Integration** - Correlate velocity with quality metrics, assess technical debt impact, evaluate sustainable pace, measure team satisfaction
+
+**Advanced Features**: Monte Carlo forecasting, velocity trend decomposition, capacity planning optimization, performance anomaly detection, sustainable pace analysis.
+
+**Predictive Analytics**: Sprint outcome predictions, delivery timeline forecasting, capacity requirement planning, performance trend analysis.
+
+**Output**: Comprehensive velocity analysis with predictive forecasts, optimization recommendations, capacity planning insights, and sustainable performance strategies.

package/components/commands/team/team-workload-balancer.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Bash, Grep, Glob
+argument-hint: [analysis-type] | --current-workload | --skill-matching | --capacity-planning | --assignment-optimization
+description: Analyze and optimize team workload distribution with skill matching and capacity planning
+model: sonnet
+---
+
+# Team Workload Balancer
+
+Analyze and optimize team workload distribution with intelligent assignment recommendations: **$ARGUMENTS**
+
+## Current Team Context
+
+- Team size: !`git log --format='%ae' --since='1 month ago' | sort -u | wc -l` active team members
+- Active tasks: Linear MCP query for current sprint tasks and assignments
+- Recent activity: !`git log --oneline --since='1 week ago' | wc -l` commits in last week
+- Capacity metrics: Analysis of team velocity and individual contribution patterns
+
+## Task
+
+Execute comprehensive workload analysis with intelligent assignment optimization:
+
+**Analysis Type**: Use $ARGUMENTS to focus on current workload assessment, skill matching, capacity planning, or assignment optimization
+
+**Workload Balancing Framework**:
+1. **Current Workload Assessment** - Analyze task distribution, evaluate individual capacity, assess deadline pressure, identify overloaded team members
+2. **Skill Matching Analysis** - Map team member expertise, identify skill gaps, assess learning opportunities, optimize skill utilization
+3. **Capacity Planning** - Calculate available capacity, project future workload, plan skill development, optimize resource allocation
+4. **Performance Integration** - Analyze historical performance, identify productivity patterns, assess collaboration effectiveness, factor in availability constraints
+5. **Assignment Optimization** - Generate optimal task assignments, balance workload distribution, maximize skill utilization, minimize bottlenecks
+6. **Risk Mitigation** - Identify single points of failure, plan cross-training, assess knowledge distribution, ensure backup coverage
+
+**Advanced Features**: Predictive workload modeling, skill gap analysis, burnout prevention, performance-based assignment, dynamic rebalancing recommendations.
+
+**Quality Metrics**: Workload distribution equity, skill utilization efficiency, team satisfaction indicators, delivery predictability measures.
+
+**Output**: Comprehensive workload analysis with optimized assignments, capacity recommendations, skill development plans, and team health insights.

package/components/commands/testing/add-mutation-testing.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [language] | --javascript | --java | --python | --rust | --go | --csharp
+description: Setup comprehensive mutation testing with framework selection and CI integration
+model: sonnet
+---
+
+# Add Mutation Testing
+
+Setup mutation testing framework with quality metrics and CI integration: **$ARGUMENTS**
+
+## Current Testing Context
+
+- Language: !`find . -name "*.js" -o -name "*.ts" | head -1 >/dev/null && echo "JavaScript/TypeScript" || find . -name "*.py" | head -1 >/dev/null && echo "Python" || find . -name "*.java" | head -1 >/dev/null && echo "Java" || echo "Multi-language"`
+- Test coverage: !`find . -name "coverage" -o -name ".nyc_output" | head -1 || echo "No coverage data"`
+- Test framework: !`grep -l "jest\\|mocha\\|pytest\\|junit" package.json pom.xml setup.py 2>/dev/null | head -1 || echo "Detect from tests"`
+- CI system: !`find . -name ".github" -o -name ".gitlab-ci.yml" -o -name "Jenkinsfile" | head -1 || echo "No CI detected"`
+
+## Task
+
+Implement comprehensive mutation testing with framework optimization and quality gates:
+
+**Language Focus**: Use $ARGUMENTS to specify JavaScript, Java, Python, Rust, Go, C#, or auto-detect from codebase
+
+**Mutation Testing Framework**:
+1. **Tool Selection & Setup** - Choose framework (Stryker, PIT, mutmut, cargo-mutants), install dependencies, configure basic settings, validate installation
+2. **Mutation Operator Configuration** - Configure arithmetic operators, relational operators, logical operators, conditional boundaries, statement mutations
+3. **Performance Optimization** - Setup parallel execution, configure incremental testing, optimize file filtering, implement caching strategies
+4. **Quality Metrics** - Configure mutation score calculation, setup survival analysis, implement threshold enforcement, track effectiveness trends
+5. **CI/CD Integration** - Automate execution triggers, configure performance monitoring, setup result reporting, implement deployment gates
+6. **Result Analysis** - Setup visualization dashboards, configure surviving mutant analysis, implement remediation workflows, track regression patterns
+
+**Advanced Features**: Selective mutation testing, performance profiling, automated test improvement suggestions, mutation trend analysis, quality gate integration.
+
+**Framework Support**: Language-specific optimizations, tool ecosystem integration, performance tuning, reporting customization.
+
+**Output**: Complete mutation testing setup with configured framework, CI integration, quality thresholds, and analysis workflows.

package/components/commands/testing/add-property-based-testing.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [language] | --javascript | --python | --java | --haskell | --rust | --clojure
+description: Implement property-based testing with framework selection and invariant identification
+model: sonnet
+---
+
+# Add Property-Based Testing
+
+Implement property-based testing framework with invariant analysis and test generation: **$ARGUMENTS**
+
+## Current Testing Context
+
+- Language: !`find . -name "*.js" -o -name "*.ts" | head -1 >/dev/null && echo "JavaScript/TypeScript" || find . -name "*.py" | head -1 >/dev/null && echo "Python" || echo "Multi-language"`
+- Test framework: !`find . -name "jest.config.*" -o -name "pytest.ini" | head -1 || echo "Detect framework"`
+- Mathematical functions: Analysis of codebase for property-testable functions
+- Business logic: Identification of invariants and properties in domain logic
+
+## Task
+
+Implement comprehensive property-based testing with invariant analysis and automated test generation:
+
+**Language Focus**: Use $ARGUMENTS to specify JavaScript, Python, Java, Haskell, Rust, Clojure, or auto-detect from codebase
+
+**Property-Based Testing Framework**:
+1. **Framework Selection** - Choose appropriate tool (fast-check, Hypothesis, QuickCheck, proptest), install dependencies, configure integration
+2. **Property Identification** - Analyze mathematical properties, identify business invariants, discover symmetries, evaluate round-trip properties
+3. **Generator Design** - Create custom data generators, implement constraint-based generation, design composite generators, optimize generation strategies
+4. **Property Implementation** - Write property tests, implement preconditions, design postconditions, create invariant checks
+5. **Shrinking Configuration** - Configure test case shrinking, optimize failure minimization, implement custom shrinkers, enhance debugging
+6. **Integration & Reporting** - Integrate with existing test suite, configure reporting, setup CI integration, optimize execution performance
+
+**Advanced Features**: Stateful property testing, model-based testing, custom generators, parallel property execution, performance property testing.
+
+**Quality Assurance**: Property completeness analysis, edge case coverage, performance optimization, maintainability assessment.
+
+**Output**: Complete property-based testing setup with identified properties, custom generators, integrated test suite, and performance optimization.