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

package/commands/experiments/xanalytics.md

@@ -0,0 +1,113 @@
+---
+description: Comprehensive business metrics tracking, user behavior analysis, and performance analytics for data-driven decisions
+tags: [analytics, metrics, business, performance, reporting, insights]
+---
+
+Analyze business metrics and performance data based on the arguments provided in $ARGUMENTS.
+
+First, examine the project for analytics setup:
+!find . -name "*.json" -o -name "*.yml" -o -name "*.yaml" | grep -E "(analytics|metrics|config)" | head -5
+!ls -la package.json requirements.txt 2>/dev/null | head -2
+!ps aux | grep -E "(analytics|prometheus|grafana)" | grep -v grep
+
+Based on $ARGUMENTS, perform the appropriate analytics operation:
+
+## 1. Business Metrics Analysis
+
+If analyzing business metrics (--business, --revenue, --conversion):
+!find . -name "*.sql" -o -name "*analytics*" | head -5 2>/dev/null
+!grep -r "revenue\|conversion\|funnel" . --include="*.py" --include="*.js" | head -5 2>/dev/null
+!python -c "import pandas; print('Analytics libraries available')" 2>/dev/null || echo "Install analytics dependencies"
+
+Analyze business performance:
+- Revenue trends and forecasting
+- Conversion funnel optimization
+- Customer retention analysis
+- Churn prediction modeling
+- ROI and profitability metrics
+
+## 2. User Behavior Analytics
+
+If analyzing user behavior (--users, --journeys, --segments):
+!find . -name "*event*" -o -name "*tracking*" | head -5 2>/dev/null
+!grep -r "user_id\|session\|event" . --include="*.py" --include="*.js" | head -5 2>/dev/null
+!curl -s http://localhost:3000/health 2>/dev/null || echo "Application not running locally"
+
+Analyze user patterns:
+- User journey mapping and optimization
+- Behavioral segmentation analysis
+- Engagement and retention metrics
+- A/B test result analysis
+- User acquisition channel performance
+
+## 3. Performance Analytics
+
+If analyzing performance (--performance, --latency, --throughput):
+!find . -name "*log*" -o -name "*metrics*" | head -5 2>/dev/null
+!netstat -tuln 2>/dev/null | grep -E "(9090|3000|8080)" || echo "No monitoring ports detected"
+!docker ps | grep -E "(prometheus|grafana)" || echo "No monitoring containers running"
+
+Analyze system performance:
+- Response time and latency analysis
+- Throughput and capacity planning
+- Error rate and pattern detection
+- Resource utilization optimization
+- SLA compliance monitoring
+
+## 4. Custom Analytics Implementation
+
+If implementing custom analytics (--custom, --dashboard, --alerts):
+!find . -name "*dashboard*" -o -name "*alert*" | head -5 2>/dev/null
+!python -c "import matplotlib, seaborn; print('Visualization libraries available')" 2>/dev/null || echo "Install visualization dependencies"
+!ls -la config/ analytics/ dashboards/ 2>/dev/null || echo "No analytics configuration found"
+
+Implement custom solutions:
+- Custom metric definition and tracking
+- Interactive dashboard creation
+- Alert threshold configuration
+- Data pipeline automation
+- Real-time monitoring setup
+
+## 5. Predictive Analytics
+
+If running predictive analytics (--predictions, --forecast, --anomaly):
+!python -c "import sklearn, numpy; print('ML libraries available')" 2>/dev/null || echo "Install ML dependencies: pip install scikit-learn numpy"
+!find . -name "*model*" -o -name "*predict*" | head -5 2>/dev/null
+!ls -la data/ models/ predictions/ 2>/dev/null || echo "No ML artifacts found"
+
+Perform predictive analysis:
+- Machine learning model training
+- Forecasting and trend prediction
+- Anomaly detection implementation
+- Seasonal pattern analysis
+- Risk assessment modeling
+
+Think step by step about analytics requirements and provide:
+
+1. **Data Assessment**:
+   - Available data sources identification
+   - Data quality and completeness evaluation
+   - Integration requirements analysis
+   - Privacy and compliance considerations
+
+2. **Analytics Strategy**:
+   - Key performance indicators definition
+   - Measurement framework design
+   - Dashboard and reporting requirements
+   - Alert and notification setup
+
+3. **Implementation Plan**:
+   - Data pipeline architecture
+   - Visualization and dashboard setup
+   - Monitoring and alerting configuration
+   - Machine learning model development
+
+4. **Insights and Recommendations**:
+   - Performance trend analysis
+   - Optimization opportunities identification
+   - Business impact assessment
+   - Action plan development
+
+Generate comprehensive analytics implementation with data collection, visualization, monitoring, and actionable insights.
+
+If no specific operation is provided, perform analytics readiness assessment and recommend implementation strategy based on current setup and business requirements.

package/commands/experiments/xanalyze.md

@@ -0,0 +1,70 @@
+---
+description: Comprehensive code analysis for quality, patterns, and issue identification
+tags: [analysis, quality, refactoring]
+---
+
+Analyze the codebase for quality issues, patterns, and improvements.
+
+First, examine the project structure:
+!find . -type f -name "*.py" -o -name "*.js" -o -name "*.ts" | grep -v node_modules | grep -v __pycache__ | head -20
+
+Based on the file structure and the arguments provided ($ARGUMENTS), perform the following analysis:
+
+1. **Code Structure Analysis**:
+   - Identify architectural patterns and anti-patterns
+   - Check for circular dependencies
+   - Analyze module coupling and cohesion
+   - Look for code duplication
+
+2. **Quality Metrics**:
+   - Calculate cyclomatic complexity for functions
+   - Check type annotation coverage
+   - Identify functions longer than 50 lines
+   - Find classes with more than 10 methods
+
+3. **Security Issues**:
+   - Look for hardcoded credentials or API keys
+   - Check for SQL injection vulnerabilities
+   - Identify missing input validation
+   - Find exposed sensitive data
+
+4. **Performance Concerns**:
+   - Identify N+1 query patterns
+   - Find inefficient loops or algorithms
+   - Check for missing database indexes
+   - Look for synchronous operations that could be async
+
+For Python projects, run:
+!python -m pylint **/*.py --output-format=json 2>/dev/null || echo "Pylint not available"
+!python -m mypy . --ignore-missing-imports 2>/dev/null || echo "Mypy not available"
+
+For JavaScript/TypeScript projects, run:
+!npx eslint . --format json 2>/dev/null || echo "ESLint not available"
+
+Think step by step about the analysis results and provide:
+- A quality score (0-10) with justification
+- Top 5 issues to fix with specific file locations
+- Concrete recommendations for each issue
+- Quick wins that can be implemented immediately
+
+If specific analysis options were provided in $ARGUMENTS (like --security, --performance, --types), focus the analysis on those areas.
+
+Generate a summary report in this format:
+```
+📊 Code Analysis Report
+━━━━━━━━━━━━━━━━━━━━━
+Quality Score: X/10
+
+🔴 Critical Issues:
+- [Issue description] at file:line
+
+🟡 Warnings:
+- [Issue description] at file:line
+
+💡 Recommendations:
+1. [Specific actionable recommendation]
+2. [Specific actionable recommendation]
+
+⚡ Quick Wins:
+- [Easy fix with high impact]
+```

package/commands/experiments/xapi.md

@@ -0,0 +1,161 @@
+---
+description: Design, implement, test, and document APIs with comprehensive automation and best practices
+tags: [api, development, testing, documentation, openapi, rest, graphql]
+---
+
+Design, implement, test, and document APIs based on the arguments provided in $ARGUMENTS.
+
+First, examine the project structure and API configuration:
+!ls -la | grep -E "(api|server|app|openapi|swagger)"
+!find . -name "*.json" -o -name "*.yml" -o -name "*.yaml" | grep -E "(api|openapi|swagger)" | head -10
+!npm list express 2>/dev/null || python -c "import fastapi; print('FastAPI available')" 2>/dev/null || echo "No API framework detected"
+
+Based on $ARGUMENTS, perform the appropriate API operation:
+
+## 1. API Design and Planning
+
+If designing new API (--design):
+!find . -name "*.yml" -o -name "*.yaml" | grep -E "(openapi|swagger)" | head -3
+@openapi.yml 2>/dev/null || @swagger.yml 2>/dev/null || echo "No existing API specification found"
+
+Design REST API structure:
+- Analyze resource requirements from $ARGUMENTS
+- Create RESTful endpoint patterns
+- Define request/response schemas
+- Plan authentication and authorization
+- Design error handling patterns
+
+## 2. OpenAPI Specification
+
+If working with OpenAPI (--openapi):
+!find . -name "openapi.*" -o -name "swagger.*" | head -3
+!python -c "import yaml; print('YAML parsing available')" 2>/dev/null || npm list js-yaml 2>/dev/null || echo "No YAML parser available"
+
+Generate or validate OpenAPI spec:
+- Create OpenAPI 3.0 specification
+- Define API paths and operations
+- Document request/response schemas
+- Include authentication schemes
+- Add examples and descriptions
+
+## 3. Implementation Generation
+
+If generating implementation (--generate):
+!find . -name "package.json" -o -name "requirements.txt" | head -1
+!python -c "import fastapi" 2>/dev/null && echo "FastAPI available" || npm list express 2>/dev/null && echo "Express available" || echo "No API framework detected"
+
+Generate server implementation:
+- Create API routes based on specification
+- Generate request/response models
+- Implement middleware stack
+- Add validation and error handling
+- Configure database connections if needed
+
+## 4. Testing and Validation
+
+If testing API (--test):
+!find . -name "*test*" | grep -E "(api|endpoint)" | head -5
+!python -c "import requests" 2>/dev/null && echo "Python requests available" || npm list axios 2>/dev/null && echo "Axios available" || echo "No HTTP client available"
+
+Execute comprehensive API testing:
+- Unit tests for individual endpoints
+- Integration tests with database
+- Contract testing against specification
+- Load testing for performance
+- Security vulnerability scanning
+
+## 5. Documentation Generation
+
+If generating documentation (--docs):
+!find . -name "*.md" | grep -i api | head -5
+!python -c "import markdown" 2>/dev/null || npm list markdown 2>/dev/null || echo "No markdown processor available"
+
+Create comprehensive API documentation:
+- Generate interactive Swagger UI
+- Create developer documentation
+- Add usage examples and code samples
+- Document authentication flows
+- Include troubleshooting guides
+
+## 6. Security and Monitoring
+
+If adding security (--security):
+!find . -name "*.js" -o -name "*.py" | xargs grep -l "auth" | head -5
+!npm list helmet 2>/dev/null || python -c "import security" 2>/dev/null || echo "No security middleware found"
+
+Implement API security:
+- Add authentication middleware (JWT, OAuth)
+- Implement rate limiting
+- Add CORS configuration
+- Include security headers
+- Set up input validation
+
+## 7. Performance Optimization
+
+If optimizing performance (--optimize):
+!find . -name "*.log" | grep -E "(access|api)" | head -3
+!ps aux | grep -E "(node|python)" | head -5
+
+Optimize API performance:
+- Implement caching strategies
+- Add response compression
+- Optimize database queries
+- Configure connection pooling
+- Monitor response times
+
+## 8. Client SDK Generation
+
+If generating client SDKs (--sdk):
+!find . -name "openapi.*" -o -name "swagger.*" | head -1
+!python -c "import openapi_python_client" 2>/dev/null || npm list swagger-codegen 2>/dev/null || echo "No codegen tools available"
+
+Generate client libraries:
+- Create JavaScript/TypeScript SDK
+- Generate Python client library
+- Build Go SDK
+- Add authentication helpers
+- Include usage examples
+
+## 9. Deployment and Operations
+
+If deploying API (--deploy):
+!find . -name "Dockerfile" -o -name "docker-compose.yml" | head -2
+!kubectl version --client 2>/dev/null || docker --version 2>/dev/null || echo "No deployment tools available"
+
+Deploy API services:
+- Create containerized deployment
+- Configure load balancing
+- Set up health checks
+- Add monitoring and logging
+- Configure auto-scaling
+
+Think step by step about API development requirements and provide:
+
+1. **API Design Analysis**:
+   - Resource identification and relationships
+   - Endpoint structure and HTTP methods
+   - Request/response schema design
+   - Authentication and authorization requirements
+
+2. **Implementation Strategy**:
+   - Framework selection and configuration
+   - Middleware stack implementation
+   - Database integration patterns
+   - Error handling and validation
+
+3. **Testing Approach**:
+   - Unit testing for business logic
+   - Integration testing with dependencies
+   - Contract testing against specifications
+   - Performance and security testing
+
+4. **Documentation and Deployment**:
+   - Interactive API documentation
+   - Client SDK generation
+   - Deployment configuration
+   - Monitoring and maintenance
+
+Generate comprehensive API implementation with best practices, complete testing suite, and production-ready deployment configuration.
+
+If no specific operation is provided, analyze existing API structure and suggest improvements for performance, security, and maintainability.
+

package/commands/experiments/xatomic.md

@@ -0,0 +1,112 @@
+---
+description: Break complex tasks into 4-8 hour atomic units for efficient development workflow
+tags: [planning, decomposition, estimation, dependencies, workflow]
+---
+
+Decompose tasks into atomic units based on the arguments provided in $ARGUMENTS.
+
+First, examine the current project context:
+!find . -name "*.md" | xargs grep -l "TODO\|TASK\|FEATURE" | head -5 2>/dev/null
+!ls -la CHANGELOG.md ROADMAP.md PROJECT.md 2>/dev/null || echo "No project documentation found"
+!git log --oneline --since="1 month ago" | head -10
+!find . -name "*spec*" -o -name "*requirement*" | head -5 2>/dev/null
+
+Based on $ARGUMENTS, perform the appropriate task decomposition operation:
+
+## 1. Task Decomposition
+
+If decomposing tasks (--decompose, --breakdown):
+!grep -r "TODO\|FIXME\|FEATURE" . --include="*.md" --include="*.py" --include="*.js" | head -10 2>/dev/null
+!find . -name "*.spec" -o -name "*.feature" | head -5 2>/dev/null
+
+Break down complex tasks:
+- Identify core functionality requirements
+- Define clear acceptance criteria
+- Ensure 4-8 hour completion time
+- Create testable deliverables
+- Establish clear boundaries
+
+## 2. Time Estimation
+
+If estimating time (--estimate, --sizing):
+!git log --pretty=format:"%h %s" --since="1 month ago" | grep -E "(feat|fix|refactor)" | wc -l
+!find . -name "*.py" -o -name "*.js" -o -name "*.ts" | xargs wc -l | tail -1
+!git shortlog -sn --since="1 month ago" | head -5
+
+Estimate task complexity:
+- Analyze similar historical tasks
+- Consider team velocity and experience
+- Account for testing and documentation
+- Include buffer for unexpected issues
+- Validate against atomic time constraints
+
+## 3. Dependency Analysis
+
+If analyzing dependencies (--dependencies, --graph):
+!find . -name "*.py" -o -name "*.js" -o -name "*.ts" | xargs grep -l "import\|require" | head -10
+!find . -name "package.json" -o -name "requirements.txt" | head -2
+!git log --graph --oneline --since="1 month ago" | head -10
+
+Analyze task relationships:
+- Identify prerequisite tasks
+- Map data dependencies
+- Find shared resource conflicts
+- Determine integration points
+- Create execution sequence
+
+## 4. Parallel Execution Planning
+
+If finding parallel tasks (--parallel, --concurrent):
+!git branch -a | wc -l
+!find . -name "*test*" -type d | head -5 2>/dev/null
+!grep -r "@parallel\|@concurrent" . --include="*.py" --include="*.js" | head -5 2>/dev/null
+
+Identify parallelizable work:
+- Find independent task clusters
+- Identify shared resource constraints
+- Plan team member assignments
+- Optimize critical path execution
+- Minimize integration conflicts
+
+## 5. Atomicity Validation
+
+If validating atomicity (--validate, --verify):
+!find . -name "*.md" | xargs grep -l "acceptance criteria\|definition of done" | head -5 2>/dev/null
+!git log --pretty=format:"%h %s %an %ad" --date=short --since="1 month ago" | head -10
+
+Validate task structure:
+- Verify 4-8 hour completion target
+- Check clear acceptance criteria
+- Ensure testable outcomes
+- Validate single responsibility
+- Confirm independent execution
+
+Think step by step about task decomposition requirements and provide:
+
+1. **Task Analysis**:
+   - Complex task breakdown identification
+   - Scope and boundary definition
+   - Acceptance criteria specification
+   - Risk and complexity assessment
+
+2. **Decomposition Strategy**:
+   - Atomic unit identification
+   - Logical grouping and sequencing
+   - Dependency mapping and analysis
+   - Parallel execution opportunities
+
+3. **Estimation Framework**:
+   - Historical data analysis
+   - Complexity factor assessment
+   - Team velocity consideration
+   - Buffer and risk allocation
+
+4. **Execution Planning**:
+   - Priority and sequence definition
+   - Resource allocation strategy
+   - Integration point identification
+   - Progress tracking methodology
+
+Generate comprehensive task decomposition with atomic units, time estimates, dependency analysis, and execution planning.
+
+If no specific operation is provided, perform task complexity assessment and recommend decomposition strategy based on current project state and requirements.

package/commands/experiments/xaws.md

@@ -0,0 +1,85 @@
+---
+description: AWS integration for credentials, services, and IAM testing with moto mocking
+tags: [aws, cloud, testing, security]
+---
+
+Manage AWS services integration and testing based on the arguments provided in $ARGUMENTS.
+
+First, check if this is a Python project and if AWS dependencies are available:
+!ls -la | grep -E "(requirements.txt|pyproject.toml|setup.py)"
+!pip list | grep -E "(boto3|moto|pytest)" 2>/dev/null || echo "Missing AWS dependencies"
+
+Based on $ARGUMENTS, perform the appropriate AWS operation:
+
+## 1. AWS Credentials and Configuration
+
+If checking credentials (--credentials):
+!aws configure list 2>/dev/null || echo "AWS CLI not configured"
+!aws sts get-caller-identity 2>/dev/null || echo "Invalid credentials or no access"
+
+If setting up profiles (--profiles):
+!aws configure list-profiles 2>/dev/null
+Show available AWS profiles and guide user through profile setup if needed.
+
+## 2. AWS Service Testing with Moto
+
+If setting up mocking (--mock, --mock-setup):
+!pip install moto[all] boto3 pytest 2>/dev/null || echo "Install required: pip install moto[all] boto3 pytest"
+
+Create mock environment setup:
+```python
+# Mock AWS services for testing
+import boto3
+from moto import mock_s3, mock_iam, mock_lambda
+
+@mock_s3
+def test_s3_operations():
+    s3 = boto3.client('s3', region_name='us-east-1')
+    # Add test implementations
+```
+
+## 3. IAM Policy Testing
+
+If testing IAM (--test-iam, --test-policies):
+!python -c "import boto3; print('Testing IAM policy simulation...')"
+
+Validate IAM policies and permissions:
+- Check policy syntax
+- Test policy simulation
+- Verify least privilege principles
+
+## 4. Service Operations
+
+For S3 operations (--s3):
+!aws s3 ls 2>/dev/null || echo "S3 access denied or not configured"
+
+For Lambda operations (--lambda):
+!aws lambda list-functions --max-items 5 2>/dev/null || echo "Lambda access denied"
+
+For DynamoDB operations (--dynamodb):
+!aws dynamodb list-tables 2>/dev/null || echo "DynamoDB access denied"
+
+## 5. Security Scanning
+
+If running security scan (--security-scan):
+!pip install checkov 2>/dev/null
+!checkov -f terraform/ --framework terraform 2>/dev/null || echo "No Terraform files found"
+
+Scan for:
+- Hardcoded credentials in code
+- Overly permissive IAM policies
+- Unencrypted resources
+- Public S3 buckets
+
+Think step by step about AWS best practices and security considerations.
+
+For integration testing (--integration-test):
+!python -m pytest tests/test_aws*.py -v 2>/dev/null || echo "No AWS tests found"
+
+Provide specific recommendations based on findings:
+- Security improvements needed
+- Cost optimization opportunities  
+- Performance enhancements
+- Compliance gaps
+
+If no specific operation is provided, guide the user through AWS setup and suggest next steps.