claude-code-templates 1.21.5 → 1.21.6

package/components/commands/testing/e2e-setup.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [framework] | --cypress | --playwright | --webdriver | --puppeteer | --mobile
+description: Configure comprehensive end-to-end testing suite with framework selection and CI integration
+model: sonnet
+---
+
+# E2E Setup
+
+Configure comprehensive end-to-end testing suite with framework optimization: **$ARGUMENTS**
+
+## Current E2E Context
+
+- Application type: !`find . -name "index.html" -o -name "app.js" -o -name "App.tsx" | head -1 && echo "Web app" || echo "Detect app type"`
+- Framework: !`grep -l "react\\|vue\\|angular" package.json 2>/dev/null || echo "Detect framework"`
+- Existing tests: !`find . -name "cypress" -o -name "playwright" -o -name "e2e" | head -1 || echo "No E2E setup"`
+- CI system: !`find . -name ".github" -o -name ".gitlab-ci.yml" | head -1 || echo "No CI detected"`
+
+## Task
+
+Implement comprehensive end-to-end testing with framework selection and optimization:
+
+**Framework Focus**: Use $ARGUMENTS to specify Cypress, Playwright, WebDriver, Puppeteer, mobile testing, or auto-detect best fit
+
+**E2E Testing Framework**:
+1. **Framework Selection & Setup** - Choose optimal E2E tool, install dependencies, configure basic settings, setup project structure
+2. **Test Environment Configuration** - Setup test environments, configure base URLs, implement environment switching, optimize test isolation
+3. **Page Object Patterns** - Design page object model, create reusable components, implement element selectors, optimize maintainability
+4. **Test Data Management** - Setup test data strategies, implement fixtures, configure database seeding, design cleanup procedures
+5. **Cross-Browser Testing** - Configure multi-browser execution, setup mobile testing, implement responsive testing, optimize compatibility
+6. **CI/CD Integration** - Configure automated execution, setup parallel testing, implement reporting, optimize performance
+
+**Advanced Features**: Visual regression testing, accessibility testing, performance monitoring, API testing integration, mobile device testing.
+
+**Quality Assurance**: Test reliability optimization, flaky test prevention, execution speed optimization, debugging capabilities.
+
+**Output**: Complete E2E testing setup with framework configuration, test suites, CI integration, and maintenance workflows.

package/components/commands/testing/generate-test-cases.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [target] | [scope] | --unit | --integration | --edge-cases | --automatic
+description: Generate comprehensive test cases with automatic analysis and coverage optimization
+model: sonnet
+---
+
+# Generate Test Cases
+
+Generate comprehensive test cases with automatic analysis and intelligent coverage: **$ARGUMENTS**
+
+## Current Test Generation Context
+
+- Target code: Analysis of $ARGUMENTS for test case generation requirements
+- Test framework: !`find . -name "jest.config.*" -o -name "*.test.*" | head -1 && echo "Jest/Vitest detected" || echo "Detect framework"`
+- Code complexity: !`find . -name "*.js" -o -name "*.ts" -o -name "*.py" | xargs wc -l 2>/dev/null | tail -1 | awk '{print $1}' || echo "0"` lines of code
+- Existing patterns: !`find . -name "*.test.*" -o -name "*.spec.*" | head -3` test file patterns
+
+## Task
+
+Execute intelligent test case generation with comprehensive coverage and optimization:
+
+**Generation Scope**: Use $ARGUMENTS to specify target file, unit tests, integration tests, edge cases, or automatic comprehensive generation
+
+**Test Case Generation Framework**:
+1. **Code Structure Analysis** - Parse function signatures, analyze control flow, identify branching paths, assess complexity metrics
+2. **Test Pattern Recognition** - Analyze existing test patterns, identify testing conventions, extract reusable patterns, optimize consistency
+3. **Input Space Analysis** - Identify parameter domains, analyze boundary conditions, discover edge cases, evaluate error conditions
+4. **Test Case Design** - Generate positive test cases, negative test cases, boundary value tests, equivalence class tests
+5. **Mock Strategy Planning** - Identify external dependencies, design mock implementations, create test data factories, optimize test isolation
+6. **Coverage Optimization** - Ensure path coverage, optimize test efficiency, eliminate redundancy, maximize testing value
+
+**Advanced Features**: Automatic edge case discovery, intelligent input generation, test data synthesis, coverage gap analysis, performance test generation.
+
+**Quality Assurance**: Test maintainability, execution performance, assertion quality, debugging effectiveness.
+
+**Output**: Comprehensive test case suite with optimized coverage, intelligent mocking, proper assertions, and maintenance guidelines.

package/components/commands/testing/generate-tests.md

@@ -0,0 +1,82 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [file-path] | [component-name]
+description: Generate comprehensive test suite with unit, integration, and edge case coverage
+model: sonnet
+---
+
+# Generate Tests
+
+Generate comprehensive test suite for: $ARGUMENTS
+
+## Current Testing Setup
+
+- Test framework: @package.json or @jest.config.js or @vitest.config.js (detect framework)
+- Existing tests: !`find . -name "*.test.*" -o -name "*.spec.*" | head -5`
+- Test coverage: !`npm run test:coverage 2>/dev/null || echo "No coverage script"`
+- Target file: @$ARGUMENTS (if file path provided)
+
+## Task
+
+I'll analyze the target code and create complete test coverage including:
+
+1. Unit tests for individual functions and methods
+2. Integration tests for component interactions  
+3. Edge case and error handling tests
+4. Mock implementations for external dependencies
+5. Test utilities and helpers as needed
+6. Performance and snapshot tests where appropriate
+
+## Process
+
+I'll follow these steps:
+
+1. Analyze the target file/component structure
+2. Identify all testable functions, methods, and behaviors
+3. Examine existing test patterns in the project
+4. Create test files following project naming conventions
+5. Implement comprehensive test cases with proper setup/teardown
+6. Add necessary mocks and test utilities
+7. Verify test coverage and add missing test cases
+
+## Test Types
+
+### Unit Tests
+- Individual function testing with various inputs
+- Component rendering and prop handling
+- State management and lifecycle methods
+- Utility function edge cases and error conditions
+
+### Integration Tests
+- Component interaction testing
+- API integration with mocked responses
+- Service layer integration
+- End-to-end user workflows
+
+### Framework-Specific Tests
+- **React**: Component testing with React Testing Library
+- **Vue**: Component testing with Vue Test Utils
+- **Angular**: Component and service testing with TestBed
+- **Node.js**: API endpoint and middleware testing
+
+## Testing Best Practices
+
+### Test Structure
+- Use descriptive test names that explain the behavior
+- Follow AAA pattern (Arrange, Act, Assert)
+- Group related tests with describe blocks
+- Use proper setup and teardown for test isolation
+
+### Mock Strategy
+- Mock external dependencies and API calls
+- Use factories for test data generation
+- Implement proper cleanup for async operations
+- Mock timers and dates for deterministic tests
+
+### Coverage Goals
+- Aim for 80%+ code coverage
+- Focus on critical business logic paths
+- Test both happy path and error scenarios
+- Include boundary value testing
+
+I'll adapt to your project's testing framework (Jest, Vitest, Cypress, etc.) and follow established patterns.

package/components/commands/testing/setup-comprehensive-testing.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [scope] | --unit | --integration | --e2e | --visual | --performance | --full-stack
+description: Setup complete testing infrastructure with framework configuration and CI integration
+model: sonnet
+---
+
+# Setup Comprehensive Testing
+
+Setup complete testing infrastructure with multi-layer testing strategy: **$ARGUMENTS**
+
+## Current Testing Infrastructure
+
+- Project type: !`[ -f package.json ] && echo "Node.js" || [ -f requirements.txt ] && echo "Python" || [ -f pom.xml ] && echo "Java" || echo "Multi-language"`
+- Existing tests: !`find . -name "*.test.*" -o -name "*.spec.*" | wc -l` test files
+- CI system: !`find . -name ".github" -o -name ".gitlab-ci.yml" -o -name "Jenkinsfile" | head -1 || echo "No CI detected"`
+- Framework: !`grep -l "jest\\|vitest\\|pytest\\|junit" package.json requirements.txt pom.xml 2>/dev/null | head -1 || echo "Detect framework"`
+
+## Task
+
+Implement comprehensive testing infrastructure with multi-layer testing strategy:
+
+**Setup Scope**: Use $ARGUMENTS to focus on unit, integration, e2e, visual, performance testing, or full-stack implementation
+
+**Comprehensive Testing Framework**:
+1. **Testing Strategy Design** - Analyze project requirements, define testing pyramid, plan coverage goals, optimize testing investment
+2. **Unit Testing Setup** - Configure primary framework (Jest, Vitest, pytest), setup test runners, implement test utilities, optimize execution
+3. **Integration Testing** - Setup integration test framework, configure test databases, implement API testing, optimize test isolation
+4. **E2E Testing Configuration** - Setup browser testing (Cypress, Playwright), configure test environments, implement page objects
+5. **Visual & Performance Testing** - Setup visual regression testing, configure performance benchmarks, implement accessibility testing
+6. **CI/CD Integration** - Configure automated test execution, setup parallel testing, implement quality gates, optimize pipeline performance
+
+**Advanced Features**: Contract testing, chaos engineering, load testing, security testing, cross-browser testing, mobile testing.
+
+**Infrastructure Quality**: Test reliability, execution performance, maintainability, scalability, cost optimization.
+
+**Output**: Complete testing infrastructure with configured frameworks, CI integration, quality metrics, and maintenance workflows.

package/components/commands/testing/setup-load-testing.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [testing-type] | --capacity | --stress | --spike | --endurance | --volume
+description: Configure comprehensive load testing with performance metrics and bottleneck identification
+model: sonnet
+---
+
+# Setup Load Testing
+
+Configure comprehensive load testing with performance analysis and bottleneck identification: **$ARGUMENTS**
+
+## Current Performance Context
+
+- Application type: !`find . -name "server.js" -o -name "app.py" -o -name "main.go" | head -1 && echo "Server application" || echo "Detect app type"`
+- API endpoints: !`grep -r "app\\.get\\|app\\.post\\|@RequestMapping" . 2>/dev/null | wc -l` detected endpoints
+- Database: !`find . -name "*.sql" -o -name "database.js" | head -1 && echo "Database detected" || echo "No database files"`
+- Current monitoring: !`find . -name "prometheus.yml" -o -name "newrelic.js" | head -1 || echo "No monitoring detected"`
+
+## Task
+
+Implement comprehensive load testing with performance optimization and bottleneck analysis:
+
+**Testing Type**: Use $ARGUMENTS to focus on capacity planning, stress testing, spike testing, endurance testing, or volume testing
+
+**Load Testing Framework**:
+1. **Strategy & Requirements** - Analyze application architecture, define testing objectives, determine scenarios, identify performance metrics
+2. **Tool Selection & Setup** - Choose appropriate tools (k6, Artillery, JMeter, Gatling), install dependencies, configure environments
+3. **Test Scenario Design** - Create realistic user scenarios, implement API test scripts, configure data generation, design load patterns
+4. **Performance Metrics** - Configure response time monitoring, throughput measurement, error rate tracking, resource utilization monitoring
+5. **Infrastructure Setup** - Configure test environments, setup monitoring dashboards, implement result collection, optimize test execution
+6. **Analysis & Optimization** - Identify performance bottlenecks, analyze resource constraints, recommend optimizations, track improvements
+
+**Advanced Features**: Distributed load generation, real-time monitoring, automated performance regression detection, CI/CD integration, chaos engineering.
+
+**Quality Assurance**: Test reliability, result accuracy, environment consistency, monitoring completeness.
+
+**Output**: Complete load testing setup with configured scenarios, performance monitoring, bottleneck analysis, and optimization recommendations.

package/components/commands/testing/setup-visual-testing.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [testing-scope] | --components | --pages | --responsive | --cross-browser | --accessibility
+description: Setup comprehensive visual regression testing with cross-browser and responsive testing
+model: sonnet
+---
+
+# Setup Visual Testing
+
+Setup comprehensive visual regression testing with responsive and accessibility validation: **$ARGUMENTS**
+
+## Current Visual Testing Context
+
+- Frontend framework: !`grep -l "react\\|vue\\|angular" package.json 2>/dev/null || echo "Detect framework"`
+- UI components: !`find . -name "components" -o -name "src" | head -1 && echo "Component structure detected" || echo "Analyze structure"`
+- Existing testing: !`find . -name "cypress" -o -name "playwright" -o -name "storybook" | head -1 || echo "No visual testing"`
+- CI system: !`find . -name ".github" -o -name ".gitlab-ci.yml" | head -1 || echo "No CI detected"`
+
+## Task
+
+Implement comprehensive visual testing with regression detection and accessibility validation:
+
+**Testing Scope**: Use $ARGUMENTS to focus on component testing, page testing, responsive testing, cross-browser testing, or accessibility testing
+
+**Visual Testing Framework**:
+1. **Tool Selection & Setup** - Choose visual testing tools (Percy, Chromatic, BackstopJS, Playwright), configure integration, setup environments
+2. **Baseline Creation** - Capture visual baselines, organize screenshot structure, implement version control, optimize image management
+3. **Test Scenario Design** - Create component tests, design page workflows, implement responsive breakpoints, configure browser matrix
+4. **Integration Setup** - Configure CI/CD integration, setup automated execution, implement review workflows, optimize performance
+5. **Regression Detection** - Configure diff algorithms, setup threshold management, implement approval workflows, optimize accuracy
+6. **Advanced Testing** - Setup accessibility testing, configure cross-browser validation, implement responsive testing, design performance monitoring
+
+**Advanced Features**: Automated visual testing, intelligent diff analysis, accessibility compliance checking, responsive design validation, performance visual metrics.
+
+**Quality Assurance**: Test reliability, false positive reduction, maintainability optimization, execution performance.
+
+**Output**: Complete visual testing setup with baseline management, regression detection, CI integration, and comprehensive validation workflows.

package/components/commands/testing/test-automation-orchestrator.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [orchestration-type] | --parallel | --sequential | --conditional | --pipeline-optimization
+description: Orchestrate comprehensive test automation with intelligent execution and optimization
+model: sonnet
+---
+
+# Test Automation Orchestrator
+
+Orchestrate intelligent test automation with execution optimization and resource management: **$ARGUMENTS**
+
+## Current Orchestration Context
+
+- Test suites: !`find . -name "*.test.*" -o -name "*.spec.*" | wc -l` test files across project
+- Test frameworks: !`find . -name "jest.config.*" -o -name "cypress.config.*" -o -name "playwright.config.*" | wc -l` configured frameworks
+- CI system: !`find . -name ".github" -o -name ".gitlab-ci.yml" | head -1 || echo "No CI detected"`
+- Resource usage: Analysis of current test execution patterns and performance
+
+## Task
+
+Implement intelligent test orchestration with execution optimization and resource management:
+
+**Orchestration Type**: Use $ARGUMENTS to focus on parallel execution, sequential execution, conditional testing, or pipeline optimization
+
+**Test Orchestration Framework**:
+1. **Test Discovery & Classification** - Analyze test suites, classify test types, assess execution requirements, optimize categorization
+2. **Execution Strategy Design** - Design parallel execution strategies, implement intelligent batching, optimize resource allocation, configure conditional execution
+3. **Dependency Management** - Analyze test dependencies, implement execution ordering, configure prerequisite validation, optimize dependency resolution
+4. **Resource Optimization** - Configure parallel execution, implement resource pooling, optimize memory usage, design scalable execution
+5. **Pipeline Integration** - Design CI/CD integration, implement stage orchestration, configure failure handling, optimize feedback loops
+6. **Monitoring & Analytics** - Implement execution monitoring, configure performance tracking, design failure analysis, optimize reporting
+
+**Advanced Features**: AI-driven test selection, predictive execution optimization, dynamic resource allocation, intelligent failure recovery, cost optimization.
+
+**Quality Assurance**: Execution reliability, performance consistency, resource efficiency, maintainability optimization.
+
+**Output**: Complete test orchestration system with optimized execution, intelligent resource management, comprehensive monitoring, and performance analytics.

package/components/commands/testing/test-changelog-automation.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [automation-type] | --changelog | --workflow-demo | --ci-integration | --validation
+description: Automate changelog testing workflow with CI integration and validation
+model: sonnet
+---
+
+# Test Changelog Automation
+
+Automate changelog testing workflow with comprehensive CI integration: **$ARGUMENTS**
+
+## Current Automation Context
+
+- Changelog files: !`find . -name "CHANGELOG*" -o -name "changelog*" | head -1 || echo "No changelog detected"`
+- CI system: !`find . -name ".github" -o -name ".gitlab-ci.yml" -o -name "Jenkinsfile" | head -1 || echo "No CI detected"`
+- Version control: !`git status >/dev/null 2>&1 && echo "Git repository" || echo "No git repository"`
+- Release process: Analysis of existing release automation and versioning
+
+## Task
+
+Implement comprehensive changelog automation with testing and validation workflows:
+
+**Automation Type**: Use $ARGUMENTS to focus on changelog automation, workflow demonstration, CI integration, or validation testing
+
+**Changelog Automation Framework**:
+1. **Automation Setup** - Configure changelog generation, setup version control integration, implement automated updates, design validation rules
+2. **Workflow Integration** - Design CI/CD integration, configure automated triggers, implement validation checks, optimize execution performance
+3. **Testing Strategy** - Create changelog validation tests, implement format verification, design content validation, setup regression testing
+4. **Quality Assurance** - Configure automated formatting, implement consistency checks, setup content validation, optimize maintenance workflows
+5. **Validation Framework** - Design automated validation rules, implement compliance checking, configure error reporting, optimize feedback loops
+6. **CI Integration** - Setup automated execution, configure deployment triggers, implement notification systems, optimize pipeline performance
+
+**Advanced Features**: Automated release note generation, semantic versioning integration, automated documentation updates, compliance validation.
+
+**Quality Metrics**: Changelog accuracy, automation reliability, validation effectiveness, maintenance efficiency.
+
+**Output**: Complete changelog automation with testing workflows, CI integration, validation rules, and maintenance procedures.

package/components/commands/testing/test-coverage.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [coverage-type] | --line | --branch | --function | --statement | --report
+description: Analyze and improve test coverage with comprehensive reporting and gap identification
+model: sonnet
+---
+
+# Test Coverage
+
+Analyze and improve test coverage with detailed reporting and gap analysis: **$ARGUMENTS**
+
+## Current Coverage Context
+
+- Test framework: !`find . -name "jest.config.*" -o -name ".nycrc*" -o -name "coverage.xml" | head -1 || echo "Detect framework"`
+- Coverage tools: !`npm ls nyc jest @jest/core 2>/dev/null | grep -E "nyc|jest" | head -2 || echo "No JS coverage tools"`
+- Existing coverage: !`find . -name "coverage" -type d | head -1 && echo "Coverage data exists" || echo "No coverage data"`
+- Test files: !`find . -name "*.test.*" -o -name "*.spec.*" | wc -l` test files
+
+## Task
+
+Execute comprehensive coverage analysis with improvement recommendations and reporting:
+
+**Coverage Type**: Use $ARGUMENTS to focus on line coverage, branch coverage, function coverage, statement coverage, or comprehensive reporting
+
+**Coverage Analysis Framework**:
+1. **Coverage Tool Setup** - Configure appropriate tools (Jest, NYC, Istanbul, Coverage.py, JaCoCo), setup collection settings, optimize performance, enable reporting
+2. **Coverage Measurement** - Generate line coverage, branch coverage, function coverage, statement coverage reports, identify uncovered code paths
+3. **Gap Analysis** - Identify critical uncovered paths, analyze coverage quality, assess business logic coverage, evaluate edge case handling
+4. **Threshold Management** - Configure coverage thresholds, implement quality gates, setup trend monitoring, enforce minimum standards
+5. **Reporting & Visualization** - Generate detailed reports, create coverage dashboards, implement trend analysis, setup automated notifications
+6. **Improvement Planning** - Prioritize coverage gaps, recommend test additions, identify refactoring opportunities, plan coverage enhancement
+
+**Advanced Features**: Differential coverage analysis, coverage trend monitoring, integration with code review, automated coverage alerts, performance impact assessment.
+
+**Quality Insights**: Coverage quality assessment, test effectiveness analysis, maintainability correlation, risk area identification.
+
+**Output**: Comprehensive coverage analysis with detailed reports, gap identification, improvement recommendations, and quality metrics tracking.

package/components/commands/testing/test-quality-analyzer.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [analysis-type] | --coverage-quality | --test-effectiveness | --maintainability | --performance-analysis
+description: Analyze test suite quality with comprehensive metrics and improvement recommendations
+model: sonnet
+---
+
+# Test Quality Analyzer
+
+Analyze test suite quality with comprehensive metrics and actionable improvement insights: **$ARGUMENTS**
+
+## Current Quality Context
+
+- Test coverage: !`find . -name "coverage" -type d | head -1 && echo "Coverage data available" || echo "No coverage data"`
+- Test files: !`find . -name "*.test.*" -o -name "*.spec.*" | wc -l` test files
+- Test complexity: Analysis of test suite maintainability and effectiveness patterns
+- Performance metrics: Current test execution times and resource utilization
+
+## Task
+
+Execute comprehensive test quality analysis with improvement recommendations and optimization strategies:
+
+**Analysis Type**: Use $ARGUMENTS to focus on coverage quality, test effectiveness, maintainability analysis, or performance analysis
+
+**Test Quality Analysis Framework**:
+1. **Coverage Quality Assessment** - Analyze coverage depth, evaluate coverage quality, assess edge case handling, identify coverage gaps
+2. **Test Effectiveness Evaluation** - Measure defect detection capability, analyze test reliability, assess assertion quality, evaluate test value
+3. **Maintainability Analysis** - Evaluate test code quality, analyze test organization, assess refactoring needs, optimize test structure
+4. **Performance Assessment** - Analyze execution performance, identify bottlenecks, optimize test speed, reduce resource consumption
+5. **Anti-Pattern Detection** - Identify testing anti-patterns, detect flaky tests, analyze test smells, recommend corrections
+6. **Quality Metrics Tracking** - Implement quality scoring, track improvement trends, configure quality gates, optimize quality processes
+
+**Advanced Features**: AI-powered quality assessment, predictive quality modeling, automated improvement suggestions, quality trend analysis, benchmark comparison.
+
+**Quality Insights**: Test ROI analysis, quality correlation analysis, maintenance cost assessment, effectiveness benchmarking.
+
+**Output**: Comprehensive quality analysis with detailed metrics, improvement recommendations, optimization strategies, and quality tracking framework.

package/components/commands/testing/testing_plan_integration.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [target-code] | [test-type] | --rust | --inline | --refactoring-suggestions
+description: Create comprehensive integration testing plan with inline tests and refactoring recommendations
+model: sonnet
+---
+
+# Testing Plan Integration
+
+Create integration testing plan with inline test strategy and refactoring suggestions: **$ARGUMENTS**
+
+## Current Testing Context
+
+- Project type: !`[ -f Cargo.toml ] && echo "Rust project" || [ -f package.json ] && echo "Node.js project" || echo "Multi-language project"`
+- Test framework: !`find . -name "*.test.*" -o -name "*.spec.*" | head -3` existing tests
+- Target code: Analysis of $ARGUMENTS for testability assessment
+- Integration complexity: Assessment of component interactions and dependencies
+
+## Task
+
+Execute comprehensive integration testing plan with testability analysis:
+
+**Planning Focus**: Use $ARGUMENTS to specify target code, test type requirements, Rust inline testing, or refactoring suggestions
+
+**Integration Testing Framework**:
+1. **Code Testability Analysis** - Analyze target code structure, identify testing challenges, assess coupling levels, evaluate dependency injection
+2. **Test Strategy Design** - Design integration test approach, plan inline vs separate test files, identify test boundaries, optimize test isolation
+3. **Refactoring Assessment** - Identify testability improvements, suggest dependency injection, recommend interface abstractions, optimize component boundaries
+4. **Test Case Planning** - Design integration scenarios, identify critical paths, plan data flow testing, assess error handling coverage
+5. **Mock Strategy** - Plan external dependency mocking, design test doubles, identify integration boundaries, optimize test performance
+6. **Execution Planning** - Design test execution order, plan test data management, optimize test environment setup, ensure test isolation
+
+**Advanced Features**: Rust-style inline testing, property-based integration tests, contract testing, service virtualization, chaos engineering integration.
+
+**Quality Assurance**: Test maintainability, execution performance, coverage optimization, feedback loop efficiency.
+
+**Output**: Comprehensive integration test plan with test case specifications, refactoring recommendations, implementation strategy, and quality metrics.

package/components/commands/testing/write-tests.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [target-file] | [test-type] | --unit | --integration | --e2e | --component
+description: Write comprehensive unit and integration tests with proper mocking and coverage
+model: sonnet
+---
+
+# Write Tests
+
+Write comprehensive unit and integration tests with framework-specific best practices: **$ARGUMENTS**
+
+## Current Testing Context
+
+- Test framework: !`find . -name "jest.config.*" -o -name "*.test.*" | head -1 && echo "Jest/Vitest detected" || echo "Detect framework"`
+- Target file: Analysis of $ARGUMENTS for test requirements and complexity
+- Project patterns: !`find . -name "*.test.*" -o -name "*.spec.*" | head -3` existing test patterns
+- Coverage setup: !`grep -l "coverage" package.json jest.config.* 2>/dev/null | head -1 || echo "Setup needed"`
+
+## Task
+
+Execute comprehensive test writing with framework-specific optimizations and best practices:
+
+**Test Focus**: Use $ARGUMENTS to specify target file, unit tests, integration tests, e2e tests, or component tests
+
+**Test Writing Framework**:
+1. **Code Analysis** - Analyze target code structure, identify testable functions, assess dependency complexity, evaluate edge cases
+2. **Test Strategy Design** - Plan test organization, design test hierarchies, identify mock requirements, optimize test isolation
+3. **Framework Integration** - Setup framework-specific patterns, configure test utilities, implement proper assertions, optimize test performance
+4. **Mock Implementation** - Design dependency mocks, implement test doubles, create factory functions, setup async handling
+5. **Test Case Generation** - Write unit tests, integration tests, edge cases, error scenarios, performance tests, snapshot tests
+6. **Quality Assurance** - Ensure test maintainability, optimize execution speed, validate coverage, implement proper cleanup
+
+**Advanced Features**: Property-based testing, contract testing, visual regression testing, accessibility testing, performance benchmarking.
+
+**Framework Support**: Jest/Vitest, React Testing Library, Vue Test Utils, Angular TestBed, Cypress, Playwright integration.
+
+**Output**: Comprehensive test suite with unit tests, integration tests, proper mocking, test utilities, and coverage optimization.

package/components/commands/utilities/all-tools.md

@@ -0,0 +1,31 @@
+# Display All Available Development Tools
+
+Display all available development tools
+
+*Command originally created by IndyDevDan (YouTube: https://www.youtube.com/@indydevdan) / DislerH (GitHub: https://github.com/disler)*
+
+## Instructions
+
+Display all available tools from your system prompt in the following format:
+
+1. **List each tool** with its TypeScript function signature
+2. **Include the purpose** of each tool as a suffix
+3. **Use double line breaks** between tools for readability
+4. **Format as bullet points** for clear organization
+
+The output should help developers understand:
+- What tools are available in the current Claude Code session
+- The exact function signatures for reference
+- The primary purpose of each tool
+
+Example format:
+```typescript
+• functionName(parameters: Type): ReturnType - Purpose of the tool
+
+• anotherFunction(params: ParamType): ResultType - What this tool does
+```
+
+This command is useful for:
+- Quick reference of available capabilities
+- Understanding tool signatures
+- Planning which tools to use for specific tasks