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

package/commands/experiments/xobservable.md

@@ -0,0 +1,114 @@
+---
+description: Analyze development patterns, team productivity, and process health through comprehensive observability
+tags: [observability, metrics, patterns, productivity, tracing, insights]
+---
+
+Analyze development observability and patterns based on the arguments provided in $ARGUMENTS.
+
+First, examine the project for observability indicators:
+!find . -name "*.log" -o -name "*.json" | grep -E "(metric|trace|log)" | head -5
+!git log --oneline --since="1 month ago" | wc -l
+!find . -name "*test*" -type f | wc -l
+!git branch -r | wc -l
+
+Based on $ARGUMENTS, perform the appropriate observability analysis:
+
+## 1. Development Metrics Collection
+
+If collecting metrics (--metrics, --dashboard):
+!git log --pretty=format:"%h %ad %s" --date=short --since="1 month ago" | head -10
+!find . -name "*.py" -o -name "*.js" -o -name "*.ts" | xargs wc -l | tail -1
+!git log --pretty=format:"%an" --since="1 month ago" | sort | uniq -c | sort -nr
+
+Collect development metrics:
+- Commit frequency and patterns
+- Code churn and complexity trends
+- Team collaboration indicators
+- Feature delivery velocity
+- Quality metrics evolution
+
+## 2. Pattern Analysis
+
+If analyzing patterns (--patterns, --behavior):
+!git log --pretty=format:"%H %s" --since="1 month ago" | grep -i -E "(fix|bug|refactor|feature)" | wc -l
+!find . -name "*test*" -type f -exec grep -l "describe\|it\|test" {} \; | wc -l
+!git log --pretty=format:"%ad" --date=format:"%H" --since="1 month ago" | sort | uniq -c
+
+Analyze development patterns:
+- Code change patterns and hotspots
+- Testing behavior and coverage trends
+- Work time distribution analysis
+- Collaboration and review patterns
+- Technical debt accumulation
+
+## 3. Performance Tracing
+
+If tracing operations (--trace, --timing):
+!ls -la .git/logs/refs/heads/ 2>/dev/null | head -5
+!find . -name "*.log" | xargs grep -i "duration\|time\|performance" 2>/dev/null | head -5
+!git log --pretty=format:"%H %ct" --since="1 week ago" | head -10
+
+Trace development operations:
+- TDD cycle timing analysis
+- Build and test execution times
+- Code review duration tracking
+- Deployment frequency measurement
+- Issue resolution time analysis
+
+## 4. Team Productivity Analysis
+
+If analyzing productivity (--productivity, --team):
+!git shortlog -sn --since="1 month ago"
+!git log --pretty=format:"%an %ad" --date=short --since="1 month ago" | sort | uniq -c
+!find . -name "*.md" -o -name "*.txt" | xargs grep -l "TODO\|FIXME" | wc -l
+
+Analyze team productivity:
+- Individual contribution patterns
+- Knowledge sharing indicators
+- Documentation coverage trends
+- Technical debt markers
+- Skill development tracking
+
+## 5. Process Health Assessment
+
+If assessing process health (--health, --compliance):
+!git log --grep="test" --oneline --since="1 month ago" | wc -l
+!find . -name "*.yml" -o -name "*.yaml" | xargs grep -l "test\|ci\|cd" 2>/dev/null | wc -l
+!git log --pretty=format:"%s" --since="1 month ago" | grep -E "^(feat|fix|docs|style|refactor|test|chore)" | wc -l
+
+Assess process health:
+- TDD adherence measurement
+- CI/CD pipeline effectiveness
+- Code review compliance
+- Security practice adoption
+- Documentation completeness
+
+Think step by step about development observability requirements and provide:
+
+1. **Current State Analysis**:
+   - Development velocity assessment
+   - Quality trend identification
+   - Team collaboration patterns
+   - Process adherence measurement
+
+2. **Pattern Insights**:
+   - Code change hotspot analysis
+   - Testing behavior patterns
+   - Work distribution insights
+   - Productivity bottleneck identification
+
+3. **Optimization Opportunities**:
+   - Process improvement recommendations
+   - Tool adoption suggestions
+   - Team efficiency enhancements
+   - Quality improvement strategies
+
+4. **Monitoring Recommendations**:
+   - Key metrics to track continuously
+   - Alert threshold configurations
+   - Dashboard setup guidance
+   - Trend analysis automation
+
+Generate comprehensive observability analysis with actionable insights, pattern identification, productivity recommendations, and monitoring setup guidance.
+
+If no specific operation is provided, perform development health assessment and recommend observability improvements based on current patterns and industry best practices.

package/commands/experiments/xoidc.md

@@ -0,0 +1,165 @@
+---
+description: Automate AWS OIDC role creation for GitHub Actions with local policy discovery
+tags: [aws, oidc, github-actions, security, automation]
+---
+
+Automate the creation of AWS OIDC roles for GitHub Actions with intelligent policy discovery from local aws_policies folders.
+
+## Usage Examples
+
+```bash
+# Basic usage with policy discovery
+/xoidc --github-org myorg --github-repo myrepo
+
+# With custom policies directory
+/xoidc --github-org myorg --github-repo myrepo --policies-dir custom_policies
+
+# Dry run validation
+/xoidc --github-org myorg --github-repo myrepo --dry-run
+
+# Full configuration
+/xoidc --github-org myorg --github-repo myrepo --region us-west-2 --github-token $GITHUB_TOKEN
+```
+
+## Arguments
+
+- `--github-org`: GitHub organization name (required)
+- `--github-repo`: GitHub repository name (required)
+- `--region`: AWS region (default: us-east-1)
+- `--policies-dir`: Custom policies directory (default: aws_policies)
+- `--stack-name`: Custom CloudFormation stack name
+- `--dry-run`: Validate policies without deployment
+- `--github-token`: GitHub PAT for repository variable setting
+
+## Implementation
+
+First, check for required dependencies and validate environment:
+Check if AWS CLI is available. If not found, display error message.
+Check if GitHub CLI is available. If not found, display warning about limited features.
+
+Parse arguments from $ARGUMENTS and set defaults:
+- GITHUB_ORG: Extract from --github-org parameter
+- GITHUB_REPO: Extract from --github-repo parameter  
+- REGION: Extract from --region parameter or default to "us-east-1"
+- POLICIES_DIR: Extract from --policies-dir parameter or default to "aws_policies"
+- STACK_NAME: Extract from --stack-name parameter or generate from org/repo names
+- DRY_RUN: Set to true if --dry-run flag is present
+- GITHUB_TOKEN: Extract from --github-token parameter
+
+Validate that required arguments are provided:
+- Exit with error if --github-org is missing
+- Exit with error if --github-repo is missing
+
+## 1. Policy Discovery
+
+Scan for AWS policies in the specified directory:
+Display message indicating scanning for policies in the policies directory.
+Check if the policies directory exists. If not found, display error and exit.
+
+List discovered policy files:
+Find all JSON files in the policies directory, excluding example files, and display them sorted.
+
+Store policy files for processing:
+Get list of policy files and validate that at least one policy file was found.
+If no policy files found, display error and exit.
+
+## 2. Policy Validation
+
+Validate each policy file structure:
+Display message indicating policy validation is starting.
+For each policy file found:
+- Display validation message with filename
+- Validate JSON syntax using jq
+- Check for required Version field (should be "2012-10-17")
+- Validate Statement array exists and is properly formatted
+- Check for overly permissive policies (wildcard actions or resources)
+- Display warnings for any issues found but continue processing
+
+## 3. Generate Trust Policy
+
+Create trust policy for GitHub OIDC:
+Display message indicating trust policy generation.
+Create a trust policy JSON file with:
+- Version "2012-10-17"
+- Allow effect for GitHub OIDC provider
+- Principal federated to GitHub Actions OIDC provider
+- Action for AssumeRoleWithWebIdentity
+- Conditions for audience and subject matching the specific GitHub org/repo
+- Replace variables with actual GitHub org and repo names
+
+## 4. Create CloudFormation Template
+
+Generate CloudFormation template:
+Display message indicating CloudFormation template creation.
+Create a CloudFormation template with:
+- AWSTemplateFormatVersion: '2010-09-09'
+- Description for the GitHub OIDC Role
+- Parameters for GitHubOrg and GitHubRepo
+- GitHubOIDCProvider resource with proper thumbprint
+- GitHubActionsRole resource with:
+  - Role name following pattern: GitHubActions-{org}-{repo}
+  - Trust policy referencing the OIDC provider
+  - Conditions for audience and subject validation
+- Inline policies section populated from discovered policy files
+- Output for the Role ARN
+
+For each policy file found:
+- Add as inline policy to the IAM role
+- Use filename (without .json) as policy name
+- Include full policy document content with proper indentation
+
+Add outputs section with Role ARN for easy reference.
+
+## 5. Deploy or Validate
+
+Set stack name if not provided:
+Generate stack name using pattern: gha-oidc-{github-org}-{github-repo}
+
+If dry run mode is enabled:
+- Display dry run message
+- Validate CloudFormation template using AWS CLI
+- Display validation success message
+- List discovered policy files
+- Exit without deploying
+
+Deploy the CloudFormation stack:
+- Display deployment message with stack name
+- Use AWS CLI to deploy the CloudFormation template
+- Include required capabilities for IAM resource creation
+- Pass GitHub org and repo as parameters
+- Use specified AWS region
+
+Get the role ARN from the stack output:
+- Query the deployed stack for outputs
+- Extract the RoleArn output value
+- Store for use in GitHub configuration
+
+## 6. Configure GitHub Repository Variable
+
+Set repository variable if GitHub token is provided:
+If GitHub token is available and GitHub CLI is installed:
+- Display configuration message
+- Set GitHub token in environment
+- Use GitHub CLI to set repository variable 'GHA_OIDC_ROLE_ARN'
+- Display success message
+
+If GitHub token is not provided:
+- Display manual step instruction
+- Show the Role ARN that needs to be set manually
+
+## 7. Generate Usage Instructions
+
+Display completion message and setup summary:
+- Show success message: "🎉 OIDC Role Setup Complete!"
+- Display divider line
+- Show stack name, role ARN, and region
+- List all policies that were applied
+- Display GitHub Actions workflow usage example with:
+  - Job configuration with required permissions
+  - AWS credentials configuration step
+  - Role ARN variable reference
+  - Region configuration
+- Show completion message
+
+Clean up temporary files:
+Remove temporary files created during the process (trust policy, CloudFormation template, backup files).

package/commands/experiments/xoptimize.md

@@ -0,0 +1,115 @@
+---
+description: Find and apply performance improvements, optimize workflows, and enhance resource utilization
+tags: [optimization, performance, profiling, bottlenecks, efficiency, resource-management]
+---
+
+Analyze and optimize code performance, processes, and resources based on the arguments provided in $ARGUMENTS.
+
+First, examine the project for optimization opportunities:
+!find . -name "*.py" -o -name "*.js" -o -name "*.ts" | head -10
+!ps aux | head -5
+!df -h | head -5
+!free -h 2>/dev/null || vm_stat 2>/dev/null || echo "Memory info not available"
+
+Based on $ARGUMENTS, perform the appropriate optimization operation:
+
+## 1. Code Performance Optimization
+
+If optimizing code (--code, --algorithms):
+!python -c "import cProfile; print('Profiling available')" 2>/dev/null || echo "Install profiling tools"
+!find . -name "*.py" -exec grep -l "for.*in.*for" {} \; 2>/dev/null | head -5
+!grep -r "SELECT.*FROM" . --include="*.py" --include="*.js" | head -5 2>/dev/null
+
+Analyze and optimize code performance:
+- Profile CPU-intensive functions and algorithms
+- Identify nested loop inefficiencies
+- Optimize database query patterns
+- Reduce memory allocation overhead
+- Implement caching strategies
+
+## 2. Build and CI/CD Optimization
+
+If optimizing processes (--build, --ci-cd):
+!find . -name "Dockerfile" -o -name "docker-compose.yml" | head -3
+!ls -la .github/workflows/ 2>/dev/null || echo "No CI/CD workflows found"
+!npm list --depth=0 2>/dev/null | wc -l || echo "No npm dependencies"
+
+Optimize development processes:
+- Reduce build time through caching
+- Parallelize test execution
+- Optimize CI/CD pipeline stages
+- Streamline deployment processes
+- Reduce dependency installation time
+
+## 3. Resource Utilization Optimization
+
+If optimizing resources (--dependencies, --memory):
+!find . -name "requirements.txt" -o -name "package.json" | head -2
+!du -sh node_modules/ 2>/dev/null || echo "No node_modules directory"
+!docker images --format "table {{.Repository}}:{{.Tag}}\t{{.Size}}" 2>/dev/null | head -5
+
+Optimize resource usage:
+- Analyze and reduce dependency footprint
+- Optimize memory usage patterns
+- Minimize storage requirements
+- Reduce network request overhead
+- Optimize container image sizes
+
+## 4. Performance Profiling and Analysis
+
+If profiling performance (--profile, --benchmark):
+!python -m cProfile -o profile.stats -c "import main" 2>/dev/null || echo "No main module for profiling"
+!time python -c "print('Timing test')" 2>/dev/null || echo "Python not available"
+!uptime
+
+Execute performance analysis:
+- Profile application bottlenecks
+- Benchmark critical functions
+- Identify performance hotspots
+- Measure resource consumption
+- Generate performance baselines
+
+## 5. Database and Network Optimization
+
+If optimizing data access (--database, --network):
+!find . -name "*.sql" | head -5 2>/dev/null || echo "No SQL files found"
+!grep -r "fetch\|request\|query" . --include="*.py" --include="*.js" | head -5 2>/dev/null
+!netstat -an 2>/dev/null | head -5 || echo "Network stats not available"
+
+Optimize data and network operations:
+- Analyze and optimize database queries
+- Implement connection pooling
+- Reduce network request frequency
+- Optimize data serialization
+- Implement efficient caching strategies
+
+Think step by step about optimization opportunities and provide:
+
+1. **Performance Analysis**:
+   - Current performance baseline measurement
+   - Bottleneck identification and prioritization
+   - Resource utilization assessment
+   - Performance regression detection
+
+2. **Optimization Strategy**:
+   - Code-level optimization opportunities
+   - Process improvement recommendations
+   - Resource allocation optimization
+   - Infrastructure efficiency improvements
+
+3. **Implementation Plan**:
+   - Prioritized optimization actions
+   - Expected performance improvements
+   - Risk assessment and mitigation
+   - Validation and testing approach
+
+4. **Monitoring and Validation**:
+   - Performance monitoring setup
+   - Optimization effectiveness measurement
+   - Continuous improvement recommendations
+   - Performance regression prevention
+
+Generate comprehensive optimization plan with performance analysis, prioritized improvements, implementation guidance, and monitoring recommendations.
+
+If no specific operation is provided, perform comprehensive performance assessment and recommend top optimization priorities based on impact and effort analysis.
+

package/commands/experiments/xperformance.md

@@ -0,0 +1,112 @@
+---
+description: Identify and fix performance bottlenecks with profiling and optimization
+tags: [performance, profiling, optimization]
+---
+
+Profile application performance and identify optimization opportunities.
+
+Parse performance options from $ARGUMENTS (--profile, --benchmark, --memory, --cpu, or specific function/module names).
+
+## 1. Initial Performance Check
+
+Get system information:
+!uname -a
+!python --version 2>/dev/null || node --version 2>/dev/null
+
+Check current resource usage:
+!ps aux | grep -E "(python|node)" | head -5
+!df -h | grep -v tmpfs
+
+## 2. CPU Profiling
+
+For Python projects:
+!python -m cProfile -s cumtime main.py 2>/dev/null | head -30 || echo "Add cProfile to your main script"
+
+For Node.js projects:
+!node --prof app.js 2>/dev/null && node --prof-process isolate-*.log 2>/dev/null || echo "Use node --prof for profiling"
+
+## 3. Memory Profiling
+
+Check for memory leaks and usage patterns:
+!ps aux | grep -E "(python|node)" | awk '{print $2, $3, $4, $11}'
+
+For Python memory profiling:
+!python -m memory_profiler main.py 2>/dev/null || echo "Install memory_profiler: pip install memory_profiler"
+
+## 4. Database Performance
+
+Look for slow queries:
+!grep -i "slow query" *.log 2>/dev/null | head -10
+!find . -name "*.py" -o -name "*.js" | xargs grep -n "SELECT.*FROM" | head -20
+
+## 5. Code Analysis for Performance Issues
+
+Check for common performance anti-patterns:
+!grep -r -n "for.*in.*for.*in" . --include="*.py" 2>/dev/null | head -10
+!grep -r -n "await.*forEach\|Promise\.all" . --include="*.js" 2>/dev/null | head -10
+
+Think step by step about performance bottlenecks and provide:
+
+1. Identification of top performance issues
+2. Specific optimization recommendations
+3. Code examples for fixes
+4. Expected performance improvements
+
+Generate performance report in this format:
+
+```
+⚡ PERFORMANCE ANALYSIS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Profile Duration: [X] seconds
+Total Operations: [X]
+
+🔥 HOTSPOTS (Top 5)
+─────────────────
+1. [Function/Module] - X% CPU time
+   Current: [Performance metric]
+   Issue: [What's causing slowness]
+   Fix: [Specific optimization]
+   Expected: [Improved metric]
+
+2. [Function/Module] - X% CPU time
+   [Similar details]
+
+📊 MEMORY PROFILE
+───────────────
+- Initial: X MB
+- Peak: X MB
+- Growth: X MB/hour
+- Potential leaks: [Yes/No]
+
+🎯 OPTIMIZATION RECOMMENDATIONS
+─────────────────────────────
+1. [Specific optimization with code example]
+   Before: [slow code]
+   After: [optimized code]
+   Impact: X% improvement
+
+2. [Another optimization]
+
+💡 QUICK WINS
+───────────
+• [Easy optimization 1]
+• [Easy optimization 2]
+• [Easy optimization 3]
+```
+
+If --benchmark is specified, create and run performance benchmarks:
+!python -m timeit -n 1000 "[code to benchmark]" 2>/dev/null
+!time python main.py 2>/dev/null
+
+For specific function profiling (if function name in $ARGUMENTS):
+- Profile that specific function
+- Show call count and time spent
+- Suggest optimizations
+
+Common optimizations to check for:
+- N+1 query problems
+- Inefficient loops (nested loops, unnecessary iterations)
+- Missing caching opportunities
+- Synchronous I/O that could be async
+- Large data structure copies
+- Regex compilation in loops

package/commands/experiments/xplanning.md

@@ -0,0 +1,131 @@
+---
+description: AI-assisted project planning with roadmaps, estimation, and risk analysis
+tags: [planning, roadmap, estimation, project-management]
+---
+
+# `/xplanning` - AI-Assisted Planning
+
+Strategic planning and project management with AI-driven insights and estimation.
+
+## Usage
+
+```bash
+/xplanning --roadmap         # Generate roadmap
+/xplanning --prioritize      # Prioritize tasks
+/xplanning --estimate        # Effort estimation
+/xplanning --resources       # Plan allocation
+/xplanning --risks           # Identify risks
+```
+
+## Options
+
+### `--roadmap`
+Generate strategic roadmaps with timeline and milestone planning.
+
+**Examples:**
+```bash
+/xplanning --roadmap         # Generate full roadmap
+/xplanning --roadmap --quarter Q2
+/xplanning --roadmap --epic "user-management"
+/xplanning --roadmap --dependencies
+```
+
+### `--prioritize`
+AI-driven task prioritization based on value, effort, and dependencies.
+
+**Examples:**
+```bash
+/xplanning --prioritize      # Prioritize all tasks
+/xplanning --prioritize --method "moscow"
+/xplanning --prioritize --criteria "business-value"
+/xplanning --prioritize --stakeholder "product"
+```
+
+### `--estimate`
+Effort estimation using historical data and AI analysis.
+
+**Examples:**
+```bash
+/xplanning --estimate        # Estimate all tasks
+/xplanning --estimate --task "authentication"
+/xplanning --estimate --method "story-points"
+/xplanning --estimate --confidence 90
+```
+
+### `--resources`
+Resource allocation and capacity planning.
+
+**Examples:**
+```bash
+/xplanning --resources       # View resource allocation
+/xplanning --resources --team "backend"
+/xplanning --resources --capacity
+/xplanning --resources --skills "python,aws"
+```
+
+### `--risks`
+Risk identification and mitigation planning.
+
+**Examples:**
+```bash
+/xplanning --risks           # Identify all risks
+/xplanning --risks --category "technical"
+/xplanning --risks --impact high
+/xplanning --risks --mitigation
+```
+
+## Planning Methodologies
+
+### Agile Planning
+- **Sprint Planning**: Plan sprints with velocity tracking
+- **Story Estimation**: Story point estimation and refinement
+- **Backlog Grooming**: Continuous backlog prioritization
+- **Release Planning**: Multi-sprint release coordination
+
+### Strategic Planning
+- **OKR Planning**: Objectives and Key Results framework
+- **Portfolio Planning**: Multi-project coordination
+- **Capacity Planning**: Resource and timeline optimization
+- **Scenario Planning**: Multiple timeline scenarios
+
+### Risk Management
+- **Risk Assessment**: Probability and impact analysis
+- **Mitigation Strategies**: Risk reduction planning
+- **Contingency Planning**: Backup plan development
+- **Monitor and Control**: Ongoing risk tracking
+
+## AI-Assisted Features
+
+### Intelligent Estimation
+- **Historical Analysis**: Learn from past project data
+- **Complexity Assessment**: Automatic complexity scoring
+- **Uncertainty Modeling**: Confidence intervals for estimates
+- **Team Velocity**: Velocity-based planning
+
+### Smart Prioritization
+- **Value Scoring**: Business value assessment
+- **Dependency Analysis**: Critical path identification
+- **Resource Optimization**: Skill-based task assignment
+- **Stakeholder Alignment**: Multi-stakeholder priority balancing
+
+### Predictive Analytics
+- **Delivery Forecasting**: Timeline prediction models
+- **Resource Conflicts**: Early conflict detection
+- **Scope Creep**: Scope change impact analysis
+- **Success Probability**: Project success likelihood
+
+## Integration
+
+- **Specifications**: Links to `/xspec` for requirement-driven planning
+- **Task Management**: Works with `/xatomic` for task decomposition
+- **Product**: Integrates with `/xproduct` for product planning
+- **Analytics**: Uses `/xanalytics` for data-driven insights
+- **Risk Management**: Coordinates with `/xrisk` for risk assessment
+
+## Output Formats
+
+- **Visual Roadmaps**: Timeline-based project visualization
+- **Planning Reports**: Detailed planning analysis and recommendations
+- **Resource Charts**: Capacity and allocation visualizations
+- **Risk Registers**: Comprehensive risk documentation
+- **Estimation Summaries**: Effort and timeline estimates with confidence levels