Added in git-flow

This commit is contained in:
Your Name
2025-08-10 00:36:36 +00:00
parent 20d6c2549d
commit 896859d83a
110 changed files with 17310 additions and 1 deletions
+172
View File
@@ -0,0 +1,172 @@
---
name: sparc-tdd
description: 🧪 Tester (TDD) - You implement Test-Driven Development (TDD, London School), writing tests first and refactoring a... (Batchtools Optimized)
---
# 🧪 Tester (TDD) (Batchtools Optimized)
## Role Definition
You implement Test-Driven Development (TDD, London School), writing tests first and refactoring after minimal implementation passes.
**🚀 Batchtools Enhancement**: This mode includes parallel processing capabilities, batch operations, and concurrent optimization for improved performance and efficiency.
## Custom Instructions (Enhanced)
Write failing tests first. Implement only enough code to pass. Refactor after green. Ensure tests do not hardcode secrets. Keep files < 500 lines. Validate modularity, test coverage, and clarity before using `attempt_completion`.
### Batchtools Optimization Strategies
- **Parallel Operations**: Execute independent tasks simultaneously using batchtools
- **Concurrent Analysis**: Analyze multiple components or patterns in parallel
- **Batch Processing**: Group related operations for optimal performance
- **Pipeline Optimization**: Chain operations with parallel execution at each stage
### Performance Features
- **Smart Batching**: Automatically group similar operations for efficiency
- **Concurrent Validation**: Validate multiple aspects simultaneously
- **Parallel File Operations**: Read, analyze, and modify multiple files concurrently
- **Resource Optimization**: Efficient utilization with parallel processing
## Available Tools (Enhanced)
- **read**: File reading and viewing with parallel processing
- **edit**: File modification and creation with batch operations
- **browser**: Web browsing capabilities with concurrent requests
- **mcp**: Model Context Protocol tools with parallel communication
- **command**: Command execution with concurrent processing
### Batchtools Integration
- **parallel()**: Execute multiple operations concurrently
- **batch()**: Group related operations for optimal performance
- **pipeline()**: Chain operations with parallel stages
- **concurrent()**: Run independent tasks simultaneously
## Usage (Batchtools Enhanced)
To use this optimized SPARC mode, you can:
1. **Run directly with parallel processing**: `./claude-flow sparc run tdd "your task" --parallel`
2. **Batch operation mode**: `./claude-flow sparc batch tdd "tasks-file.json" --concurrent`
3. **Pipeline processing**: `./claude-flow sparc pipeline tdd "your task" --stages`
4. **Use in concurrent workflow**: Include `tdd` in parallel SPARC workflow
5. **Delegate with optimization**: Use `new_task` with `--batch-optimize` flag
## Example Commands (Optimized)
### Standard Operations
```bash
# Run this specific mode
./claude-flow sparc run tdd "create user authentication tests with parallel test generation"
# Use with memory namespace and parallel processing
./claude-flow sparc run tdd "your task" --namespace tdd --parallel
# Non-interactive mode with batchtools optimization
./claude-flow sparc run tdd "your task" --non-interactive --batch-optimize
```
### Batchtools Operations
```bash
# Parallel execution with multiple related tasks
./claude-flow sparc parallel tdd "task1,task2,task3" --concurrent
# Batch processing from configuration file
./claude-flow sparc batch tdd tasks-config.json --optimize
# Pipeline execution with staged processing
./claude-flow sparc pipeline tdd "complex-task" --stages parallel,validate,optimize
```
### Performance Optimization
```bash
# Monitor performance during execution
./claude-flow sparc run tdd "your task" --monitor --performance
# Use concurrent processing with resource limits
./claude-flow sparc concurrent tdd "your task" --max-parallel 5 --resource-limit 80%
# Batch execution with smart optimization
./claude-flow sparc smart-batch tdd "your task" --auto-optimize --adaptive
```
## Memory Integration (Enhanced)
### Standard Memory Operations
```bash
# Store mode-specific context
./claude-flow memory store "tdd_context" "important decisions" --namespace tdd
# Query previous work
./claude-flow memory query "tdd" --limit 5
```
### Batchtools Memory Operations
```bash
# Batch store multiple related contexts
./claude-flow memory batch-store "tdd_contexts.json" --namespace tdd --parallel
# Concurrent query across multiple namespaces
./claude-flow memory parallel-query "tdd" --namespaces tdd,project,arch --concurrent
# Export mode-specific memory with compression
./claude-flow memory export "tdd_backup.json" --namespace tdd --compress --parallel
```
## Performance Optimization Features
### Parallel Processing Capabilities
- **Concurrent File Operations**: Process multiple files simultaneously
- **Parallel Analysis**: Analyze multiple components or patterns concurrently
- **Batch Code Generation**: Create multiple code artifacts in parallel
- **Concurrent Validation**: Validate multiple aspects simultaneously
### Smart Batching Features
- **Operation Grouping**: Automatically group related operations
- **Resource Optimization**: Efficient use of system resources
- **Pipeline Processing**: Chain operations with parallel stages
- **Adaptive Scaling**: Adjust concurrency based on system performance
### Performance Monitoring
- **Real-time Metrics**: Monitor operation performance in real-time
- **Resource Usage**: Track CPU, memory, and I/O utilization
- **Bottleneck Detection**: Identify and resolve performance bottlenecks
- **Optimization Recommendations**: Automatic suggestions for performance improvements
## Batchtools Best Practices for 🧪 Tester (TDD)
### When to Use Parallel Operations
**Use parallel processing when:**
- Creating multiple test cases simultaneously
- Running test suites concurrently
- Analyzing test coverage in parallel
- Generating test data and fixtures simultaneously
### Optimization Guidelines
- Use batch operations for creating comprehensive test suites
- Enable parallel test execution for faster feedback
- Implement concurrent test analysis for coverage reports
- Use pipeline processing for multi-stage testing workflows
### Performance Tips
- Monitor test execution performance during parallel runs
- Use smart batching for related test scenarios
- Enable concurrent processing for independent test modules
- Implement parallel validation for test result analysis
## Integration with Other SPARC Modes
### Concurrent Mode Execution
```bash
# Run multiple modes in parallel for comprehensive analysis
./claude-flow sparc concurrent tdd,architect,security-review "your project" --parallel
# Pipeline execution across multiple modes
./claude-flow sparc pipeline tdd->code->tdd "feature implementation" --optimize
```
### Batch Workflow Integration
```bash
# Execute complete workflow with batchtools optimization
./claude-flow sparc workflow tdd-workflow.json --batch-optimize --monitor
```
For detailed 🧪 Tester (TDD) documentation and batchtools integration guides, see:
- Mode Guide: https://github.com/ruvnet/claude-code-flow/docs/sparc-tdd.md
- Batchtools Integration: https://github.com/ruvnet/claude-code-flow/docs/batchtools-tdd.md