@paulduvall/claude-dev-toolkit 0.0.1-alpha.2 → 0.0.1-alpha.21

package/commands/experiments/xincident.md

@@ -0,0 +1,137 @@
+---
+description: Incident response automation, post-mortem analysis, and system reliability improvement through SpecDriven AI methodology
+tags: [incident-response, monitoring, post-mortem, reliability, automation]
+---
+
+# /xincident - Incident Response & Management
+
+## Purpose
+Automate incident response procedures, facilitate post-mortem analysis, and improve system reliability through SpecDriven AI methodology.
+
+## Usage
+
+### Incident Response
+```bash
+/xincident --respond <alert>      # Automated incident response procedures
+/xincident --triage <severity>    # Triage and prioritize incidents
+/xincident --escalate <level>     # Escalation procedures and notifications
+/xincident --status <incident-id> # Update incident status and timeline
+```
+
+### Communication & Coordination
+```bash
+/xincident --communicate <team>   # Generate incident communication templates
+/xincident --notify <stakeholders> # Notify relevant stakeholders
+/xincident --updates <incident-id> # Create status updates for stakeholders
+/xincident --bridge <participants> # Set up communication bridge
+```
+
+### Investigation & Analysis
+```bash
+/xincident --investigate <symptoms> # Guide investigation procedures
+/xincident --timeline <incident-id> # Build incident timeline
+/xincident --evidence <source>      # Collect and preserve evidence
+/xincident --root-cause <incident>  # Root cause analysis framework
+```
+
+### Recovery & Mitigation
+```bash
+/xincident --recover <system>     # System recovery procedures
+/xincident --rollback <deployment> # Automated rollback procedures
+/xincident --mitigate <impact>    # Implement mitigation strategies
+/xincident --validate <recovery>  # Validate recovery success
+```
+
+### Post-Mortem & Learning
+```bash
+/xincident --postmortem <id>      # Generate post-mortem template
+/xincident --lessons <incident>   # Capture lessons learned
+/xincident --actions <findings>   # Create action items from analysis
+/xincident --improvement <area>   # Process improvement recommendations
+```
+
+### Monitoring & Prevention
+```bash
+/xincident --metrics <timeframe>  # Incident metrics and trends
+/xincident --patterns <history>   # Identify recurring patterns
+/xincident --prevention <type>    # Preventive measures recommendations
+/xincident --readiness <team>     # Assess incident response readiness
+```
+
+## Examples
+
+### Respond to Production Alert
+```bash
+/xincident --respond "api-latency-high"
+# Creates: incidents/2024-01-15-api-latency/response-plan.md with automated procedures
+```
+
+### Generate Post-Mortem Report
+```bash
+/xincident --postmortem "inc-2024-001"
+# Creates: incidents/inc-2024-001/postmortem.md with timeline, root cause, and actions
+```
+
+### Escalate Critical Incident
+```bash
+/xincident --escalate "level-2"
+# Generates: escalation notifications and procedures for level-2 incidents
+```
+
+### Analyze Incident Patterns
+```bash
+/xincident --patterns "last-quarter"
+# Creates: reports/incident-patterns-q4.md with trend analysis and recommendations
+```
+
+## SpecDriven AI Integration
+
+### Incident Specifications
+- Links incidents to specifications: `{#inc1a authority=system}`
+- Traces failures to requirements
+- Validates recovery against specifications
+
+### Dual Coverage
+- **Incident Coverage**: All critical systems have response procedures
+- **Recovery Coverage**: All failure modes have documented recovery
+
+### Traceability
+- Links incidents to system specifications
+- Traces post-mortem actions to requirements
+- Connects patterns to architectural decisions
+
+## Incident Response Framework
+
+### Severity Levels
+- **SEV-1**: Critical impact, immediate response required
+- **SEV-2**: High impact, response within 1 hour
+- **SEV-3**: Medium impact, response within 4 hours
+- **SEV-4**: Low impact, response within 24 hours
+
+### Response Phases
+1. **Detection**: Alert generation and initial assessment
+2. **Response**: Immediate containment and mitigation
+3. **Recovery**: System restoration and validation
+4. **Learning**: Post-mortem and improvement actions
+
+### Communication Templates
+- **Initial Alert**: Stakeholder notification template
+- **Status Updates**: Regular progress communications
+- **Resolution Notice**: Incident closure notification
+- **Post-Mortem Summary**: Executive summary template
+
+## Integration Points
+
+- **Monitoring systems**: Alert integration and automation
+- **Communication tools**: Slack, email, and PagerDuty integration
+- **Documentation**: Links to system specifications and runbooks
+- **JIRA/GitHub**: Issue tracking and action item management
+- **CI/CD**: Automated rollback and deployment procedures
+
+## Output Formats
+
+- **Response procedures**: Step-by-step incident response guides
+- **Communication templates**: Stakeholder notification templates
+- **Post-mortem reports**: Structured analysis and learning documents
+- **Metrics dashboards**: Incident trends and performance indicators
+- **Action plans**: Improvement roadmaps and prevention strategies

package/commands/experiments/xinfra.md

@@ -0,0 +1,115 @@
+---
+description: Manage infrastructure operations, container orchestration, cloud resources, and deployment automation
+tags: [infrastructure, containers, kubernetes, cloud, terraform, monitoring, scaling]
+---
+
+Manage infrastructure operations and cloud resources based on the arguments provided in $ARGUMENTS.
+
+First, examine the current infrastructure setup:
+!find . -name "*.tf" -o -name "*.yml" -o -name "*.yaml" | grep -E "(terraform|infra|k8s|docker)" | head -10
+!ls -la docker-compose.yml Dockerfile terraform/ k8s/ infrastructure/ 2>/dev/null || echo "No infrastructure files found"
+!which docker 2>/dev/null && docker --version || echo "Docker not available"
+!which kubectl 2>/dev/null && kubectl version --client || echo "kubectl not available"
+!which terraform 2>/dev/null && terraform version || echo "Terraform not available"
+
+Based on $ARGUMENTS, perform the appropriate infrastructure operation:
+
+## 1. Container Management
+
+If managing containers (--containers, --docker, --kubernetes):
+!docker ps 2>/dev/null || echo "Docker daemon not running"
+!kubectl get nodes 2>/dev/null || echo "No Kubernetes cluster connection"
+!ls -la docker-compose.yml 2>/dev/null || echo "No docker-compose.yml found"
+
+Manage container infrastructure:
+- Docker container orchestration
+- Kubernetes cluster operations
+- Container registry management
+- Service mesh configuration
+- Resource allocation and limits
+
+## 2. Infrastructure as Code
+
+If managing IaC (--terraform, --iac, --provision):
+!find . -name "*.tf" | head -5
+!terraform --version 2>/dev/null || echo "Terraform not installed"
+!find . -name "*.yml" -o -name "*.yaml" | xargs grep -l "AWSTemplateFormatVersion\|Resources" 2>/dev/null | head -3
+
+Manage infrastructure code:
+- Terraform configuration and state
+- CloudFormation template management
+- Infrastructure provisioning automation
+- Resource dependency management
+- State management and locking
+
+## 3. Monitoring and Observability
+
+If setting up monitoring (--monitoring, --observability, --alerts):
+!find . -name "*prometheus*" -o -name "*grafana*" | head -5
+!ps aux | grep -E "(prometheus|grafana|jaeger)" | grep -v grep
+!netstat -tuln 2>/dev/null | grep -E "(9090|3000|16686)" || echo "No monitoring services detected"
+
+Configure monitoring infrastructure:
+- Prometheus metrics collection
+- Grafana dashboard setup
+- Alert manager configuration
+- Distributed tracing setup
+- Log aggregation systems
+
+## 4. Scaling and Performance
+
+If configuring scaling (--scaling, --performance, --capacity):
+!kubectl get hpa 2>/dev/null || echo "No HPA configured"
+!find . -name "*.yml" -o -name "*.yaml" | xargs grep -l "autoscaling" 2>/dev/null | head -3
+!docker stats --no-stream 2>/dev/null | head -5 || echo "No container stats available"
+
+Implement scaling strategies:
+- Horizontal Pod Autoscaling (HPA)
+- Vertical Pod Autoscaling (VPA)
+- Cluster autoscaling configuration
+- Load balancer optimization
+- Resource quota management
+
+## 5. Security and Compliance
+
+If managing security (--security, --compliance, --rbac):
+!kubectl get networkpolicies 2>/dev/null || echo "No network policies found"
+!find . -name "*.tf" | xargs grep -l "security_group\|iam_" 2>/dev/null | head -3
+!kubectl get rbac 2>/dev/null || echo "No RBAC configured"
+
+Implement security measures:
+- Network policy configuration
+- RBAC setup and management
+- Security group rules
+- Encryption at rest and in transit
+- Compliance scanning and reporting
+
+Think step by step about infrastructure requirements and provide:
+
+1. **Infrastructure Assessment**:
+   - Current infrastructure state analysis
+   - Resource utilization evaluation
+   - Security posture assessment
+   - Compliance gap identification
+
+2. **Architecture Strategy**:
+   - Scalability planning recommendations
+   - High availability design patterns
+   - Disaster recovery planning
+   - Multi-cloud considerations
+
+3. **Implementation Plan**:
+   - Infrastructure as Code setup
+   - Container orchestration strategy
+   - Monitoring and observability integration
+   - Security controls implementation
+
+4. **Operational Excellence**:
+   - Automation opportunities
+   - Cost optimization strategies
+   - Performance monitoring setup
+   - Incident response procedures
+
+Generate comprehensive infrastructure configuration with security controls, monitoring setup, scaling strategies, and operational best practices.
+
+If no specific operation is provided, perform infrastructure health assessment and recommend improvements based on current setup and industry best practices.

package/commands/experiments/xknowledge.md

@@ -0,0 +1,115 @@
+---
+description: Manage organizational knowledge, facilitate team onboarding, and create training materials with SpecDriven AI methodology
+tags: [knowledge, training, onboarding, documentation, competency, team-management]
+---
+
+Manage knowledge and team development based on the arguments provided in $ARGUMENTS.
+
+First, examine the current knowledge and documentation setup:
+!find . -name "*.md" | grep -E "(doc|knowledge|training|onboard|README)" | head -10
+!ls -la docs/ training/ onboarding/ knowledge/ 2>/dev/null || echo "No knowledge directories found"
+!find . -name "*spec*" -o -name "*requirement*" | head -5 2>/dev/null
+!git log --oneline --since="1 month ago" | grep -E "(doc|train|onboard)" | wc -l
+
+Based on $ARGUMENTS, perform the appropriate knowledge management operation:
+
+## 1. Knowledge Capture and Documentation
+
+If capturing knowledge (--capture, --document, --extract):
+!find . -name "*.py" -o -name "*.js" -o -name "*.ts" | xargs grep -l "def\|function\|class" | head -10
+!grep -r "TODO\|FIXME\|NOTE\|IMPORTANT" . --include="*.py" --include="*.js" --include="*.md" | head -10 2>/dev/null
+!find . -name "*.md" | xargs grep -l "best practice\|pattern\|guideline" | head -5 2>/dev/null
+
+Capture and document knowledge:
+- Extract domain expertise from code and comments
+- Document architectural decisions and patterns
+- Codify tribal knowledge and best practices
+- Create process and procedure documentation
+- Maintain knowledge base currency
+
+## 2. Team Onboarding
+
+If managing onboarding (--onboard, --checklist, --resources):
+!ls -la package.json requirements.txt setup.py pyproject.toml 2>/dev/null | head -3
+!find . -name "README*" -o -name "CONTRIBUTING*" -o -name "SETUP*" | head -5
+!ls -la .env.example docker-compose.yml Dockerfile 2>/dev/null | head -3
+!git remote -v 2>/dev/null || echo "No git remotes configured"
+
+Create onboarding materials:
+- Role-specific setup and configuration guides
+- Development environment setup instructions
+- Project overview and architecture documentation
+- Team processes and workflow documentation
+- Mentoring and buddy system setup
+
+## 3. Training and Development
+
+If creating training (--training, --curriculum, --exercises):
+!find . -name "*test*" -o -name "*example*" | head -10 2>/dev/null
+!ls -la training/ examples/ tutorials/ docs/learning/ 2>/dev/null || echo "No training directories found"
+!python -c "import pytest; print('Testing framework available')" 2>/dev/null || npm test --version 2>/dev/null || echo "No testing framework detected"
+
+Develop training materials:
+- Hands-on coding exercises and examples
+- Progressive skill development curricula
+- Assessment and evaluation frameworks
+- Interactive learning experiences
+- Certification and competency tracking
+
+## 4. Competency Assessment
+
+If assessing competencies (--assess, --gaps, --matrix, --skills):
+!git log --pretty=format:"%an" --since="3 months ago" | sort | uniq -c | sort -nr
+!find . -name "*.py" -o -name "*.js" -o -name "*.ts" | xargs grep -l "import\|require" | head -10
+!ls -la team/ people/ skills/ competencies/ 2>/dev/null || echo "No team documentation found"
+
+Assess and track competencies:
+- Individual skill assessment and tracking
+- Team competency gap analysis
+- Skills matrix development and maintenance
+- Personal development planning
+- Career progression pathway definition
+
+## 5. Knowledge Transfer
+
+If managing knowledge transfer (--transfer, --handover, --succession):
+!git log --pretty=format:"%h %an %s" --since="1 month ago" | head -20
+!find . -name "*.md" | xargs grep -l "handover\|transfer\|transition" | head -5 2>/dev/null
+!ls -la docs/handover/ docs/transfer/ docs/succession/ 2>/dev/null || echo "No transfer documentation found"
+
+Manage knowledge transfer:
+- Project handover documentation creation
+- Knowledge transfer session planning
+- Succession planning for critical roles
+- Documentation of critical knowledge
+- Risk mitigation for knowledge loss
+
+Think step by step about knowledge management requirements and provide:
+
+1. **Knowledge Audit**:
+   - Current knowledge base assessment
+   - Documentation gap identification
+   - Critical knowledge risk evaluation
+   - Team competency baseline
+
+2. **Documentation Strategy**:
+   - Knowledge capture methodology
+   - Documentation standards and templates
+   - Maintenance and update processes
+   - Accessibility and discoverability
+
+3. **Training Framework**:
+   - Learning path development
+   - Competency-based curriculum design
+   - Assessment and certification approach
+   - Continuous learning culture
+
+4. **Knowledge Retention**:
+   - Critical knowledge identification
+   - Transfer and succession planning
+   - Documentation automation opportunities
+   - Community and collaboration tools
+
+Generate comprehensive knowledge management plan with documentation strategy, training materials, competency frameworks, and retention mechanisms.
+
+If no specific operation is provided, perform knowledge management assessment and recommend improvements based on current documentation state and team needs.

package/commands/experiments/xmaturity.md

@@ -0,0 +1,120 @@
+---
+description: Assess and improve team's development maturity with actionable insights
+tags: [maturity, assessment, improvement]
+---
+
+Assess development maturity and provide improvement roadmap.
+
+Parse assessment options from $ARGUMENTS (--level, --assess, --roadmap, --progress, or specific area like --testing, --ci-cd).
+
+## 1. Quick Maturity Check
+
+First, gather basic project metrics:
+!find . -name "*.py" -o -name "*.js" -o -name "*.ts" | wc -l
+!find . -name "*test*" -o -name "*spec*" | wc -l
+!test -f .github/workflows/ci.yml && echo "CI/CD: GitHub Actions configured" || echo "CI/CD: Not found"
+!test -f README.md && wc -l README.md
+
+## 2. Development Practices Assessment
+
+Check version control practices:
+!git log --oneline -10 | grep -E "(feat|fix|docs|test|refactor)" | wc -l
+!git branch -r | wc -l
+
+Testing maturity:
+!python -m pytest --cov=. 2>/dev/null | grep "TOTAL" || npm test 2>/dev/null | grep "Test Suites" || echo "No test coverage data"
+
+Code quality tools:
+!test -f .pre-commit-config.yaml && echo "Pre-commit hooks: Configured" || echo "Pre-commit hooks: Not configured"
+!test -f pyproject.toml && grep -E "(black|ruff|mypy)" pyproject.toml 2>/dev/null
+
+## 3. CI/CD Maturity
+
+Check for automation:
+!find . -name "*.yml" -path "*workflow*" -o -path "*github*" | head -5
+!test -f Dockerfile && echo "Containerization: Yes" || echo "Containerization: No"
+
+## 4. Documentation & Knowledge Sharing
+
+!find . -name "*.md" | wc -l
+!test -d docs && echo "Documentation folder exists" || echo "No dedicated docs folder"
+
+Think step by step about the maturity assessment and provide:
+
+1. Current maturity level (1-5) with justification
+2. Strengths and gaps in each area
+3. Specific improvement recommendations
+4. 90-day improvement roadmap
+
+Generate maturity report in this format:
+
+```
+📊 DEVELOPMENT MATURITY ASSESSMENT
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Overall Level: X.X/5.0 (Level Name)
+
+📈 MATURITY SCORES BY AREA
+────────────────────────
+🔧 Engineering Practices
+- Version Control: X.X/5 ✓
+- Testing: X.X/5 ⚠️
+- Code Quality: X.X/5 ✓
+- Documentation: X.X/5 ❌
+
+🚀 Delivery & Operations  
+- CI/CD: X.X/5 ⚠️
+- Monitoring: X.X/5 ❌
+- Security: X.X/5 ⚠️
+
+👥 Team & Culture
+- Collaboration: X.X/5 ✓
+- Knowledge Sharing: X.X/5 ⚠️
+
+💪 STRENGTHS
+───────────
+• [Specific strength with evidence]
+• [Specific strength with evidence]
+
+🎯 TOP GAPS TO ADDRESS
+───────────────────
+1. [Gap]: Current state → Target state
+   Action: [Specific action to take]
+   
+2. [Gap]: Current state → Target state
+   Action: [Specific action to take]
+
+📅 90-DAY IMPROVEMENT ROADMAP
+─────────────────────────
+Week 1-2: Quick Wins
+• [Specific task with command/action]
+• [Specific task with command/action]
+
+Week 3-4: Foundation
+• [Specific task with command/action]
+• [Specific task with command/action]
+
+Month 2: Build Momentum
+• [Larger improvement initiative]
+• [Process implementation]
+
+Month 3: Establish Excellence
+• [Advanced practice adoption]
+• [Measurement and optimization]
+
+💡 NEXT STEPS
+───────────
+1. [Immediate action to take today]
+2. [Action to take this week]
+3. [Process to establish this month]
+```
+
+If --roadmap is specified, create detailed implementation plan.
+If --progress is specified, compare against previous assessment.
+If --benchmark is specified, compare against industry standards.
+
+Maturity Levels:
+1. Initial (Ad-hoc): Inconsistent, reactive
+2. Managed: Basic processes, some repeatability  
+3. Defined: Standardized processes, good practices
+4. Quantified: Measured, data-driven decisions
+5. Optimizing: Continuous improvement, innovation

package/commands/experiments/xmetrics.md

@@ -0,0 +1,118 @@
+---
+description: Advanced metrics collection and analysis for development process optimization and SpecDriven AI insights
+tags: [metrics, analytics, performance, quality, velocity, coverage]
+---
+
+Collect and analyze development metrics based on the arguments provided in $ARGUMENTS.
+
+First, examine the project for metrics and monitoring setup:
+!find . -name "*.json" -o -name "*.yml" -o -name "*.yaml" | grep -E "(metric|monitor|analytics)" | head -5
+!ls -la package.json requirements.txt pyproject.toml 2>/dev/null | head -3
+!ps aux | grep -E "(prometheus|grafana|analytics)" | grep -v grep
+!git log --oneline --since="1 month ago" | wc -l
+
+Based on $ARGUMENTS, perform the appropriate metrics operation:
+
+## 1. Dashboard and Overview Metrics
+
+If viewing dashboard (--dashboard, --overview):
+!find . -name "*.py" -o -name "*.js" -o -name "*.ts" | wc -l
+!find . -name "*test*" -type f | wc -l
+!git log --pretty=format:"%h %an %ad" --date=short --since="1 month ago" | wc -l
+!git shortlog -sn --since="1 month ago" | head -5
+
+Generate comprehensive metrics dashboard:
+- Development velocity and productivity
+- Code quality and coverage trends
+- Team collaboration patterns
+- Deployment and delivery metrics
+- Technical debt and risk indicators
+
+## 2. Coverage Analysis
+
+If analyzing coverage (--coverage, --dual-coverage):
+!python -m pytest --cov=. --cov-report=term 2>/dev/null || npm test -- --coverage 2>/dev/null || echo "No coverage tools available"
+!find . -name "*spec*" -o -name "*requirement*" | wc -l
+!grep -r "{#.*authority=" . --include="*.md" --include="*.py" | wc -l
+
+Analyze coverage metrics:
+- Traditional code coverage (line, branch, function)
+- Specification coverage tracking
+- Authority-level coverage analysis
+- Traceability coverage assessment
+- Coverage gap identification
+
+## 3. Velocity and Productivity Metrics
+
+If analyzing velocity (--velocity, --productivity, --team):
+!git log --pretty=format:"%h %s %an %ad" --date=short --since="1 month ago" | head -20
+!git log --pretty=format:"%an" --since="1 month ago" | sort | uniq -c | sort -nr
+!git log --oneline --since="1 week ago" | wc -l
+!git branch -r | wc -l
+
+Measure team productivity:
+- Commit frequency and patterns
+- Pull request velocity
+- Feature delivery rate
+- Sprint burndown analysis
+- Individual contributor metrics
+
+## 4. Quality Metrics
+
+If analyzing quality (--quality, --debt, --complexity):
+!find . -name "*.py" -o -name "*.js" -o -name "*.ts" | xargs wc -l | tail -1
+!grep -r "TODO\|FIXME\|HACK" . --include="*.py" --include="*.js" --include="*.ts" | wc -l
+!python -m pylint **/*.py --output-format=json 2>/dev/null | head -10 || echo "Pylint not available"
+!find . -name "*test*" -type f | wc -l
+
+Analyze code quality:
+- Cyclomatic complexity trends
+- Technical debt accumulation
+- Bug density measurements
+- Code duplication analysis
+- Maintainability index
+
+## 5. Performance and DORA Metrics
+
+If analyzing performance (--performance, --dora, --lead-time):
+!git log --pretty=format:"%h %ad %s" --date=short --since="1 month ago" | grep -E "(deploy|release|fix)" | wc -l
+!find . -name "*.yml" -o -name "*.yaml" | xargs grep -l "deploy\|ci\|cd" | head -5 2>/dev/null
+!uptime
+!ps aux | head -5
+
+Measure performance metrics:
+- Deployment frequency
+- Lead time for changes
+- Mean time to recovery (MTTR)
+- Change failure rate
+- System performance indicators
+
+Think step by step about metrics requirements and provide:
+
+1. **Current State Analysis**:
+   - Existing metrics collection setup
+   - Available data sources and quality
+   - Team velocity and productivity baseline
+   - Quality and coverage current state
+
+2. **Metrics Strategy**:
+   - Key performance indicators definition
+   - DORA metrics implementation
+   - SpecDriven AI compliance tracking
+   - Team and individual metrics framework
+
+3. **Implementation Plan**:
+   - Metrics collection automation
+   - Dashboard and visualization setup
+   - Alert and threshold configuration
+   - Reporting and analysis framework
+
+4. **Insights and Actions**:
+   - Performance trend analysis
+   - Improvement opportunity identification
+   - Predictive analytics and forecasting
+   - Actionable recommendations
+
+Generate comprehensive metrics analysis with dashboard insights, trend analysis, performance indicators, and improvement recommendations.
+
+If no specific operation is provided, perform metrics readiness assessment and recommend metrics implementation strategy based on current development setup and industry best practices.