|
|
@@ -0,0 +1,563 @@ |
|
|
#!/bin/bash |
|
|
|
|
|
# SPARC Automated Development System |
|
|
# Generic workflow for comprehensive software development using SPARC methodology |
|
|
|
|
|
set -e # Exit on any error |
|
|
|
|
|
# Default configuration |
|
|
PROJECT_NAME="sparc-project" |
|
|
README_PATH="README.md" |
|
|
MCP_CONFIG=".roo/mcp.json" |
|
|
VERBOSE=false |
|
|
DRY_RUN=false |
|
|
SKIP_RESEARCH=false |
|
|
SKIP_TESTS=false |
|
|
TEST_COVERAGE_TARGET=100 |
|
|
PARALLEL_EXECUTION=true |
|
|
COMMIT_FREQUENCY="phase" # phase, feature, or manual |
|
|
OUTPUT_FORMAT="text" |
|
|
DEVELOPMENT_MODE="full" # full, backend-only, frontend-only, api-only |
|
|
|
|
|
# Help function |
|
|
show_help() { |
|
|
cat << EOF |
|
|
SPARC Automated Development System |
|
|
================================== |
|
|
|
|
|
A comprehensive, automated software development workflow using SPARC methodology |
|
|
(Specification, Pseudocode, Architecture, Refinement, Completion) |
|
|
|
|
|
USAGE: |
|
|
./claude-sparc.sh [OPTIONS] [PROJECT_NAME] [README_PATH] |
|
|
|
|
|
ARGUMENTS: |
|
|
PROJECT_NAME Name of the project to develop (default: sparc-project) |
|
|
README_PATH Path to initial requirements/readme file (default: readme.md) |
|
|
|
|
|
OPTIONS: |
|
|
-h, --help Show this help message |
|
|
-v, --verbose Enable verbose output |
|
|
-d, --dry-run Show what would be done without executing |
|
|
-c, --config FILE MCP configuration file (default: .roo/mcp.json) |
|
|
|
|
|
# Research Options |
|
|
--skip-research Skip the web research phase |
|
|
--research-depth LEVEL Research depth: basic, standard, comprehensive (default: standard) |
|
|
|
|
|
# Development Options |
|
|
--mode MODE Development mode: full, backend-only, frontend-only, api-only (default: full) |
|
|
--skip-tests Skip test development (not recommended) |
|
|
--coverage TARGET Test coverage target percentage (default: 100) |
|
|
--no-parallel Disable parallel execution |
|
|
|
|
|
# Commit Options |
|
|
--commit-freq FREQ Commit frequency: phase, feature, manual (default: phase) |
|
|
--no-commits Disable automatic commits |
|
|
|
|
|
# Output Options |
|
|
--output FORMAT Output format: text, json, markdown (default: text) |
|
|
--quiet Suppress non-essential output |
|
|
|
|
|
EXAMPLES: |
|
|
# Basic usage |
|
|
./claude-sparc.sh my-app docs/requirements.md |
|
|
|
|
|
# Backend API development with verbose output |
|
|
./claude-sparc.sh --mode api-only --verbose user-service api-spec.md |
|
|
|
|
|
# Quick prototype without research |
|
|
./claude-sparc.sh --skip-research --coverage 80 prototype-app readme.md |
|
|
|
|
|
# Dry run to see what would be executed |
|
|
./claude-sparc.sh --dry-run --verbose my-project requirements.md |
|
|
|
|
|
DEVELOPMENT MODES: |
|
|
full Complete full-stack development (default) |
|
|
backend-only Backend services and APIs only |
|
|
frontend-only Frontend application only |
|
|
api-only REST/GraphQL API development only |
|
|
|
|
|
RESEARCH DEPTHS: |
|
|
basic Quick domain overview and technology stack research |
|
|
standard Comprehensive research including competitive analysis (default) |
|
|
comprehensive Extensive research with academic papers and detailed analysis |
|
|
|
|
|
COMMIT FREQUENCIES: |
|
|
phase Commit after each SPARC phase completion (default) |
|
|
feature Commit after each feature implementation |
|
|
manual No automatic commits (manual git operations only) |
|
|
|
|
|
For more information, see SPARC-DEVELOPMENT-GUIDE.md |
|
|
EOF |
|
|
} |
|
|
|
|
|
# Parse command line arguments |
|
|
parse_args() { |
|
|
while [[ $# -gt 0 ]]; do |
|
|
case $1 in |
|
|
-h|--help) |
|
|
show_help |
|
|
exit 0 |
|
|
;; |
|
|
-v|--verbose) |
|
|
VERBOSE=true |
|
|
shift |
|
|
;; |
|
|
-d|--dry-run) |
|
|
DRY_RUN=true |
|
|
shift |
|
|
;; |
|
|
-c|--config) |
|
|
MCP_CONFIG="$2" |
|
|
shift 2 |
|
|
;; |
|
|
--skip-research) |
|
|
SKIP_RESEARCH=true |
|
|
shift |
|
|
;; |
|
|
--research-depth) |
|
|
RESEARCH_DEPTH="$2" |
|
|
shift 2 |
|
|
;; |
|
|
--mode) |
|
|
DEVELOPMENT_MODE="$2" |
|
|
shift 2 |
|
|
;; |
|
|
--skip-tests) |
|
|
SKIP_TESTS=true |
|
|
shift |
|
|
;; |
|
|
--coverage) |
|
|
TEST_COVERAGE_TARGET="$2" |
|
|
shift 2 |
|
|
;; |
|
|
--no-parallel) |
|
|
PARALLEL_EXECUTION=false |
|
|
shift |
|
|
;; |
|
|
--commit-freq) |
|
|
COMMIT_FREQUENCY="$2" |
|
|
shift 2 |
|
|
;; |
|
|
--no-commits) |
|
|
COMMIT_FREQUENCY="manual" |
|
|
shift |
|
|
;; |
|
|
--output) |
|
|
OUTPUT_FORMAT="$2" |
|
|
shift 2 |
|
|
;; |
|
|
--quiet) |
|
|
VERBOSE=false |
|
|
shift |
|
|
;; |
|
|
-*) |
|
|
echo "Unknown option: $1" >&2 |
|
|
echo "Use --help for usage information" >&2 |
|
|
exit 1 |
|
|
;; |
|
|
*) |
|
|
if [[ "$PROJECT_NAME" == "sparc-project" ]]; then |
|
|
PROJECT_NAME="$1" |
|
|
elif [[ "$README_PATH" == "README.md" ]]; then |
|
|
README_PATH="$1" |
|
|
else |
|
|
echo "Too many arguments: $1" >&2 |
|
|
echo "Use --help for usage information" >&2 |
|
|
exit 1 |
|
|
fi |
|
|
shift |
|
|
;; |
|
|
esac |
|
|
done |
|
|
} |
|
|
|
|
|
# Validate configuration |
|
|
validate_config() { |
|
|
# Check if MCP config exists |
|
|
if [[ ! -f "$MCP_CONFIG" ]]; then |
|
|
echo "Warning: MCP config file not found: $MCP_CONFIG" >&2 |
|
|
echo "Using default MCP configuration" >&2 |
|
|
fi |
|
|
|
|
|
# Check if README exists, try to find alternatives if default doesn't exist |
|
|
if [[ ! -f "$README_PATH" ]]; then |
|
|
# Try common README file variations |
|
|
local readme_alternatives=("README.md" "readme.md" "Readme.md" "README.txt" "readme.txt") |
|
|
local found_readme="" |
|
|
|
|
|
for alt in "${readme_alternatives[@]}"; do |
|
|
if [[ -f "$alt" ]]; then |
|
|
found_readme="$alt" |
|
|
break |
|
|
fi |
|
|
done |
|
|
|
|
|
if [[ -n "$found_readme" ]]; then |
|
|
echo "README file '$README_PATH' not found, using '$found_readme' instead" >&2 |
|
|
README_PATH="$found_readme" |
|
|
else |
|
|
echo "Error: No README file found. Tried: ${readme_alternatives[*]}" >&2 |
|
|
echo "Please specify a valid README file path or create one of the above files." >&2 |
|
|
exit 1 |
|
|
fi |
|
|
fi |
|
|
|
|
|
# Validate development mode |
|
|
case $DEVELOPMENT_MODE in |
|
|
full|backend-only|frontend-only|api-only) ;; |
|
|
*) echo "Error: Invalid development mode: $DEVELOPMENT_MODE" >&2; exit 1 ;; |
|
|
esac |
|
|
|
|
|
# Validate commit frequency |
|
|
case $COMMIT_FREQUENCY in |
|
|
phase|feature|manual) ;; |
|
|
*) echo "Error: Invalid commit frequency: $COMMIT_FREQUENCY" >&2; exit 1 ;; |
|
|
esac |
|
|
|
|
|
# Validate output format |
|
|
case $OUTPUT_FORMAT in |
|
|
text|json|markdown) ;; |
|
|
*) echo "Error: Invalid output format: $OUTPUT_FORMAT" >&2; exit 1 ;; |
|
|
esac |
|
|
|
|
|
# Validate coverage target |
|
|
if [[ ! "$TEST_COVERAGE_TARGET" =~ ^[0-9]+$ ]] || [[ "$TEST_COVERAGE_TARGET" -lt 0 ]] || [[ "$TEST_COVERAGE_TARGET" -gt 100 ]]; then |
|
|
echo "Error: Invalid coverage target: $TEST_COVERAGE_TARGET (must be 0-100)" >&2 |
|
|
exit 1 |
|
|
fi |
|
|
} |
|
|
|
|
|
# Show configuration |
|
|
show_config() { |
|
|
if [[ "$VERBOSE" == true ]]; then |
|
|
cat << EOF |
|
|
SPARC Configuration: |
|
|
=================== |
|
|
Project Name: $PROJECT_NAME |
|
|
README Path: $README_PATH |
|
|
MCP Config: $MCP_CONFIG |
|
|
Development Mode: $DEVELOPMENT_MODE |
|
|
Research Depth: ${RESEARCH_DEPTH:-standard} |
|
|
Test Coverage Target: $TEST_COVERAGE_TARGET% |
|
|
Parallel Execution: $PARALLEL_EXECUTION |
|
|
Commit Frequency: $COMMIT_FREQUENCY |
|
|
Output Format: $OUTPUT_FORMAT |
|
|
Skip Research: $SKIP_RESEARCH |
|
|
Skip Tests: $SKIP_TESTS |
|
|
Dry Run: $DRY_RUN |
|
|
=================== |
|
|
EOF |
|
|
fi |
|
|
} |
|
|
|
|
|
# Build allowed tools based on configuration |
|
|
build_allowed_tools() { |
|
|
local tools="View,Edit,Replace,GlobTool,GrepTool,LS,Bash" |
|
|
|
|
|
if [[ "$SKIP_RESEARCH" != true ]]; then |
|
|
tools="$tools,WebFetchTool" |
|
|
fi |
|
|
|
|
|
if [[ "$PARALLEL_EXECUTION" == true ]]; then |
|
|
tools="$tools,BatchTool,dispatch_agent" |
|
|
fi |
|
|
|
|
|
echo "$tools" |
|
|
} |
|
|
|
|
|
# Build Claude command flags |
|
|
build_claude_flags() { |
|
|
local flags="--mcp-config $MCP_CONFIG --dangerously-skip-permissions" |
|
|
|
|
|
if [[ "$VERBOSE" == true ]]; then |
|
|
flags="$flags --verbose" |
|
|
fi |
|
|
|
|
|
if [[ "$OUTPUT_FORMAT" != "text" ]]; then |
|
|
flags="$flags --output-format $OUTPUT_FORMAT" |
|
|
fi |
|
|
|
|
|
echo "$flags" |
|
|
} |
|
|
|
|
|
# Main execution |
|
|
main() { |
|
|
parse_args "$@" |
|
|
validate_config |
|
|
show_config |
|
|
|
|
|
if [[ "$DRY_RUN" == true ]]; then |
|
|
echo "DRY RUN - Would execute the following:" |
|
|
echo "Project: $PROJECT_NAME" |
|
|
echo "README: $README_PATH" |
|
|
echo "Allowed Tools: $(build_allowed_tools)" |
|
|
echo "Claude Flags: $(build_claude_flags)" |
|
|
exit 0 |
|
|
fi |
|
|
|
|
|
# Execute the SPARC development process |
|
|
execute_sparc_development |
|
|
} |
|
|
|
|
|
# Execute SPARC development process |
|
|
execute_sparc_development() { |
|
|
local allowed_tools=$(build_allowed_tools) |
|
|
local claude_flags=$(build_claude_flags) |
|
|
|
|
|
claude " |
|
|
# SPARC Automated Development System |
|
|
# Project: ${PROJECT_NAME} |
|
|
# Initial Research Document: ${README_PATH} |
|
|
# Configuration: Mode=${DEVELOPMENT_MODE}, Coverage=${TEST_COVERAGE_TARGET}%, Parallel=${PARALLEL_EXECUTION} |
|
|
|
|
|
$(if [[ "$SKIP_RESEARCH" != true ]]; then cat << 'RESEARCH_BLOCK' |
|
|
## PHASE 0: COMPREHENSIVE RESEARCH & DISCOVERY |
|
|
### Research Depth: ${RESEARCH_DEPTH:-standard} |
|
|
### Parallel Web Research Phase ($(if [[ "$PARALLEL_EXECUTION" == true ]]; then echo "BatchTool execution"; else echo "Sequential execution"; fi)): |
|
|
|
|
|
1. **Domain Research**: |
|
|
- WebFetchTool: Extract key concepts from ${README_PATH} |
|
|
- WebFetchTool: Search for latest industry trends and technologies |
|
|
- WebFetchTool: Research competitive landscape and existing solutions |
|
|
$(if [[ "${RESEARCH_DEPTH:-standard}" == "comprehensive" ]]; then echo " - WebFetchTool: Gather academic papers and technical documentation"; fi) |
|
|
|
|
|
2. **Technology Stack Research**: |
|
|
- WebFetchTool: Research best practices for identified technology domains |
|
|
- WebFetchTool: Search for framework comparisons and recommendations |
|
|
- WebFetchTool: Investigate security considerations and compliance requirements |
|
|
$(if [[ "${RESEARCH_DEPTH:-standard}" != "basic" ]]; then echo " - WebFetchTool: Research scalability patterns and architecture approaches"; fi) |
|
|
|
|
|
3. **Implementation Research**: |
|
|
- WebFetchTool: Search for code examples and implementation patterns |
|
|
$(if [[ "$SKIP_TESTS" != true ]]; then echo " - WebFetchTool: Research testing frameworks and methodologies"; fi) |
|
|
- WebFetchTool: Investigate deployment and DevOps best practices |
|
|
$(if [[ "${RESEARCH_DEPTH:-standard}" == "comprehensive" ]]; then echo " - WebFetchTool: Research monitoring and observability solutions"; fi) |
|
|
|
|
|
### Research Processing: |
|
|
$(if [[ "$PARALLEL_EXECUTION" == true ]]; then echo "Use BatchTool to execute all research queries in parallel for maximum efficiency."; else echo "Execute research queries sequentially for thorough analysis."; fi) |
|
|
|
|
|
$(if [[ "$COMMIT_FREQUENCY" != "manual" ]]; then echo "**Commit**: 'feat: complete comprehensive research phase - gathered domain knowledge, technology insights, and implementation patterns'"; fi) |
|
|
RESEARCH_BLOCK |
|
|
fi) |
|
|
|
|
|
## SPECIFICATION PHASE |
|
|
### Requirements Analysis for ${DEVELOPMENT_MODE} development: |
|
|
1. **Functional Requirements**: |
|
|
- Analyze ${README_PATH} to extract core functionality |
|
|
- Define user stories and acceptance criteria |
|
|
- Identify system boundaries and interfaces |
|
|
$(if [[ "$DEVELOPMENT_MODE" == "full" || "$DEVELOPMENT_MODE" == "backend-only" || "$DEVELOPMENT_MODE" == "api-only" ]]; then echo " - Specify API endpoints and data models"; fi) |
|
|
$(if [[ "$DEVELOPMENT_MODE" == "full" || "$DEVELOPMENT_MODE" == "frontend-only" ]]; then echo " - Define user interface requirements and user experience flows"; fi) |
|
|
|
|
|
2. **Non-Functional Requirements**: |
|
|
- Security and compliance requirements |
|
|
- Performance benchmarks and SLAs |
|
|
- Scalability and availability targets |
|
|
- Maintainability and extensibility goals |
|
|
|
|
|
3. **Technical Constraints**: |
|
|
- Technology stack decisions based on research |
|
|
- Integration requirements and dependencies |
|
|
- Deployment and infrastructure constraints |
|
|
- Budget and timeline considerations |
|
|
|
|
|
$(if [[ "$COMMIT_FREQUENCY" == "phase" ]]; then echo "**Commit**: 'docs: complete specification phase - defined functional/non-functional requirements and technical constraints for ${DEVELOPMENT_MODE} development'"; fi) |
|
|
|
|
|
## PSEUDOCODE PHASE |
|
|
### High-Level Architecture Design for ${DEVELOPMENT_MODE}: |
|
|
1. **System Architecture**: |
|
|
$(if [[ "$DEVELOPMENT_MODE" == "full" || "$DEVELOPMENT_MODE" == "backend-only" ]]; then echo " - Define backend components and their responsibilities"; fi) |
|
|
$(if [[ "$DEVELOPMENT_MODE" == "full" || "$DEVELOPMENT_MODE" == "frontend-only" ]]; then echo " - Design frontend architecture and component hierarchy"; fi) |
|
|
$(if [[ "$DEVELOPMENT_MODE" == "api-only" ]]; then echo " - Define API architecture and endpoint structure"; fi) |
|
|
- Design data flow and communication patterns |
|
|
- Specify APIs and integration points |
|
|
- Plan error handling and recovery strategies |
|
|
|
|
|
2. **Algorithm Design**: |
|
|
- Core business logic algorithms |
|
|
- Data processing and transformation logic |
|
|
- Optimization strategies and performance considerations |
|
|
- Security and validation algorithms |
|
|
|
|
|
$(if [[ "$SKIP_TESTS" != true ]]; then cat << 'TEST_BLOCK' |
|
|
3. **Test Strategy**: |
|
|
- Unit testing approach (TDD London School) |
|
|
- Integration testing strategy |
|
|
- End-to-end testing scenarios |
|
|
- Target: ${TEST_COVERAGE_TARGET}% test coverage |
|
|
$(if [[ "$DEVELOPMENT_MODE" == "full" ]]; then echo " - Frontend and backend testing coordination"; fi) |
|
|
TEST_BLOCK |
|
|
fi) |
|
|
|
|
|
$(if [[ "$COMMIT_FREQUENCY" == "phase" ]]; then echo "**Commit**: 'design: complete pseudocode phase - defined system architecture, algorithms, and test strategy for ${DEVELOPMENT_MODE}'"; fi) |
|
|
|
|
|
## ARCHITECTURE PHASE |
|
|
### Detailed System Design for ${DEVELOPMENT_MODE}: |
|
|
1. **Component Architecture**: |
|
|
- Detailed component specifications |
|
|
- Interface definitions and contracts |
|
|
- Dependency injection and inversion of control |
|
|
- Configuration management strategy |
|
|
|
|
|
$(if [[ "$DEVELOPMENT_MODE" == "full" || "$DEVELOPMENT_MODE" == "backend-only" || "$DEVELOPMENT_MODE" == "api-only" ]]; then cat << 'DATA_BLOCK' |
|
|
2. **Data Architecture**: |
|
|
- Database schema design |
|
|
- Data access patterns and repositories |
|
|
- Caching strategies and data flow |
|
|
- Backup and recovery procedures |
|
|
DATA_BLOCK |
|
|
fi) |
|
|
|
|
|
3. **Infrastructure Architecture**: |
|
|
- Deployment architecture and environments |
|
|
- CI/CD pipeline design |
|
|
- Monitoring and logging architecture |
|
|
- Security architecture and access controls |
|
|
|
|
|
$(if [[ "$COMMIT_FREQUENCY" == "phase" ]]; then echo "**Commit**: 'arch: complete architecture phase - detailed component, data, and infrastructure design for ${DEVELOPMENT_MODE}'"; fi) |
|
|
|
|
|
## REFINEMENT PHASE (TDD Implementation) |
|
|
### $(if [[ "$PARALLEL_EXECUTION" == true ]]; then echo "Parallel"; else echo "Sequential"; fi) Development Tracks for ${DEVELOPMENT_MODE}: |
|
|
|
|
|
$(if [[ "$DEVELOPMENT_MODE" == "full" || "$DEVELOPMENT_MODE" == "backend-only" || "$DEVELOPMENT_MODE" == "api-only" ]]; then cat << 'BACKEND_BLOCK' |
|
|
#### Track 1: Backend Development |
|
|
1. **Setup & Infrastructure**: |
|
|
- Bash: Initialize project structure |
|
|
- Bash: Setup development environment |
|
|
- Bash: Configure CI/CD pipeline |
|
|
$(if [[ "$COMMIT_FREQUENCY" != "manual" ]]; then echo " - **Commit**: 'feat: initialize backend infrastructure and development environment'"; fi) |
|
|
|
|
|
$(if [[ "$SKIP_TESTS" != true ]]; then cat << 'BACKEND_TDD_BLOCK' |
|
|
2. **TDD Core Components** (London School): |
|
|
- Red: Write failing tests for core business logic |
|
|
- Green: Implement minimal code to pass tests |
|
|
- Refactor: Optimize while maintaining green tests |
|
|
- Target: ${TEST_COVERAGE_TARGET}% coverage |
|
|
$(if [[ "$COMMIT_FREQUENCY" != "manual" ]]; then echo " - **Commit**: 'feat: implement core business logic with TDD - ${TEST_COVERAGE_TARGET}% test coverage'"; fi) |
|
|
BACKEND_TDD_BLOCK |
|
|
fi) |
|
|
|
|
|
3. **API Layer Development**: |
|
|
- $(if [[ "$SKIP_TESTS" != true ]]; then echo "Red: Write API contract tests"; else echo "Implement API endpoints"; fi) |
|
|
- $(if [[ "$SKIP_TESTS" != true ]]; then echo "Green: Implement API endpoints"; else echo "Add input validation and error handling"; fi) |
|
|
- $(if [[ "$SKIP_TESTS" != true ]]; then echo "Refactor: Optimize API performance"; else echo "Optimize API performance"; fi) |
|
|
$(if [[ "$COMMIT_FREQUENCY" != "manual" ]]; then echo " - **Commit**: 'feat: complete API layer with $(if [[ "$SKIP_TESTS" != true ]]; then echo "comprehensive test coverage"; else echo "validation and error handling"; fi)'"; fi) |
|
|
BACKEND_BLOCK |
|
|
fi) |
|
|
|
|
|
$(if [[ "$DEVELOPMENT_MODE" == "full" || "$DEVELOPMENT_MODE" == "frontend-only" ]]; then cat << 'FRONTEND_BLOCK' |
|
|
#### Track 2: Frontend Development |
|
|
1. **UI Component Library**: |
|
|
- $(if [[ "$SKIP_TESTS" != true ]]; then echo "Red: Write component tests"; else echo "Implement UI components"; fi) |
|
|
- $(if [[ "$SKIP_TESTS" != true ]]; then echo "Green: Implement UI components"; else echo "Add component styling and interactions"; fi) |
|
|
- $(if [[ "$SKIP_TESTS" != true ]]; then echo "Refactor: Optimize for reusability"; else echo "Optimize for reusability and performance"; fi) |
|
|
$(if [[ "$COMMIT_FREQUENCY" != "manual" ]]; then echo " - **Commit**: 'feat: complete UI component library with $(if [[ "$SKIP_TESTS" != true ]]; then echo "full test coverage"; else echo "optimized components"; fi)'"; fi) |
|
|
|
|
|
2. **Application Logic**: |
|
|
- $(if [[ "$SKIP_TESTS" != true ]]; then echo "Red: Write application flow tests"; else echo "Implement user interactions"; fi) |
|
|
- $(if [[ "$SKIP_TESTS" != true ]]; then echo "Green: Implement user interactions"; else echo "Add state management and routing"; fi) |
|
|
- $(if [[ "$SKIP_TESTS" != true ]]; then echo "Refactor: Optimize user experience"; else echo "Optimize user experience and performance"; fi) |
|
|
$(if [[ "$COMMIT_FREQUENCY" != "manual" ]]; then echo " - **Commit**: 'feat: complete frontend application logic with $(if [[ "$SKIP_TESTS" != true ]]; then echo "end-to-end tests"; else echo "optimized user experience"; fi)'"; fi) |
|
|
FRONTEND_BLOCK |
|
|
fi) |
|
|
|
|
|
#### Track 3: Integration & Quality Assurance |
|
|
1. **Integration Testing**: |
|
|
$(if [[ "$PARALLEL_EXECUTION" == true ]]; then echo " - BatchTool: Run parallel integration test suites"; else echo " - Bash: Run integration test suites"; fi) |
|
|
- Bash: Execute performance benchmarks |
|
|
- Bash: Run security scans and audits |
|
|
$(if [[ "$COMMIT_FREQUENCY" != "manual" ]]; then echo " - **Commit**: 'test: complete integration testing with performance and security validation'"; fi) |
|
|
|
|
|
2. **Quality Gates**: |
|
|
$(if [[ "$PARALLEL_EXECUTION" == true ]]; then echo " - BatchTool: Run parallel quality checks (linting, analysis, documentation)"; else echo " - Bash: Run comprehensive linting and code quality analysis"; fi) |
|
|
- Bash: Validate documentation completeness |
|
|
$(if [[ "$COMMIT_FREQUENCY" != "manual" ]]; then echo " - **Commit**: 'quality: pass all quality gates - linting, analysis, and documentation'"; fi) |
|
|
|
|
|
### $(if [[ "$PARALLEL_EXECUTION" == true ]]; then echo "Parallel"; else echo "Sequential"; fi) Subtask Orchestration: |
|
|
$(if [[ "$PARALLEL_EXECUTION" == true ]]; then echo "Use BatchTool to execute independent development tracks in parallel where possible."; else echo "Execute development tracks sequentially for thorough validation."; fi) |
|
|
|
|
|
## COMPLETION PHASE |
|
|
### Final Integration & Deployment for ${DEVELOPMENT_MODE}: |
|
|
1. **System Integration**: |
|
|
- Integrate all development tracks |
|
|
$(if [[ "$SKIP_TESTS" != true ]]; then echo " - Run comprehensive end-to-end tests"; fi) |
|
|
- Validate against original requirements |
|
|
$(if [[ "$COMMIT_FREQUENCY" != "manual" ]]; then echo " - **Commit**: 'feat: complete system integration with full validation'"; fi) |
|
|
|
|
|
2. **Documentation & Deployment**: |
|
|
$(if [[ "$DEVELOPMENT_MODE" == "api-only" || "$DEVELOPMENT_MODE" == "backend-only" || "$DEVELOPMENT_MODE" == "full" ]]; then echo " - Generate comprehensive API documentation"; fi) |
|
|
- Create deployment guides and runbooks |
|
|
- Setup monitoring and alerting |
|
|
$(if [[ "$COMMIT_FREQUENCY" != "manual" ]]; then echo " - **Commit**: 'docs: complete documentation and deployment preparation'"; fi) |
|
|
|
|
|
3. **Production Readiness**: |
|
|
- Execute production deployment checklist |
|
|
- Validate monitoring and observability |
|
|
- Conduct final security review |
|
|
$(if [[ "$COMMIT_FREQUENCY" != "manual" ]]; then echo " - **Commit**: 'deploy: production-ready release with full monitoring and security validation'"; fi) |
|
|
|
|
|
## SPARC METHODOLOGY ENFORCEMENT |
|
|
### Quality Standards: |
|
|
- **Modularity**: All files ≤ 500 lines, functions ≤ 50 lines |
|
|
- **Security**: No hardcoded secrets, comprehensive input validation |
|
|
$(if [[ "$SKIP_TESTS" != true ]]; then echo "- **Testing**: ${TEST_COVERAGE_TARGET}% test coverage with TDD London School approach"; fi) |
|
|
- **Documentation**: Self-documenting code with strategic comments |
|
|
- **Performance**: Optimized critical paths with benchmarking |
|
|
|
|
|
### Tool Utilization Strategy: |
|
|
$(if [[ "$SKIP_RESEARCH" != true ]]; then echo "- **WebFetchTool**: Comprehensive research and documentation gathering"; fi) |
|
|
$(if [[ "$PARALLEL_EXECUTION" == true ]]; then echo "- **BatchTool**: Parallel research, testing, and quality checks"; fi) |
|
|
- **Bash**: Git operations, CI/CD, testing, and deployment |
|
|
- **Edit/Replace**: Code implementation and refactoring |
|
|
- **GlobTool/GrepTool**: Code analysis and pattern detection |
|
|
$(if [[ "$PARALLEL_EXECUTION" == true ]]; then echo "- **dispatch_agent**: Complex subtask delegation"; fi) |
|
|
|
|
|
### Commit Standards (Frequency: ${COMMIT_FREQUENCY}): |
|
|
- **feat**: New features and major functionality |
|
|
$(if [[ "$SKIP_TESTS" != true ]]; then echo "- **test**: Test implementation and coverage improvements"; fi) |
|
|
- **fix**: Bug fixes and issue resolution |
|
|
- **docs**: Documentation updates and improvements |
|
|
- **arch**: Architectural changes and design updates |
|
|
- **quality**: Code quality improvements and refactoring |
|
|
- **deploy**: Deployment and infrastructure changes |
|
|
|
|
|
### $(if [[ "$PARALLEL_EXECUTION" == true ]]; then echo "Parallel"; else echo "Sequential"; fi) Execution Strategy: |
|
|
$(if [[ "$PARALLEL_EXECUTION" == true ]]; then cat << 'PARALLEL_BLOCK' |
|
|
1. Use BatchTool for independent operations |
|
|
2. Leverage dispatch_agent for complex subtasks |
|
|
3. Implement concurrent development tracks |
|
|
4. Optimize for maximum development velocity |
|
|
PARALLEL_BLOCK |
|
|
else cat << 'SEQUENTIAL_BLOCK' |
|
|
1. Execute operations sequentially for thorough validation |
|
|
2. Focus on quality over speed |
|
|
3. Ensure each step is fully validated before proceeding |
|
|
4. Maintain clear development progression |
|
|
SEQUENTIAL_BLOCK |
|
|
fi) |
|
|
|
|
|
### Continuous Integration: |
|
|
$(if [[ "$COMMIT_FREQUENCY" != "manual" ]]; then echo "- Commit after each $(if [[ "$COMMIT_FREQUENCY" == "phase" ]]; then echo "major phase"; else echo "feature"; fi) completion"; fi) |
|
|
$(if [[ "$SKIP_TESTS" != true ]]; then echo "- Run automated tests on every commit"; fi) |
|
|
- Validate quality gates continuously |
|
|
- Monitor performance and security metrics |
|
|
|
|
|
## SUCCESS CRITERIA: |
|
|
$(if [[ "$SKIP_TESTS" != true ]]; then echo "- ✅ ${TEST_COVERAGE_TARGET}% test coverage achieved"; fi) |
|
|
- ✅ All quality gates passed |
|
|
- ✅ Production deployment successful |
|
|
- ✅ Comprehensive documentation complete |
|
|
- ✅ Security and performance validated |
|
|
- ✅ Monitoring and observability operational |
|
|
|
|
|
Continue development until all success criteria are met. $(if [[ "$PARALLEL_EXECUTION" == true ]]; then echo "Use parallel execution and subtask orchestration for maximum efficiency."; fi) $(if [[ "$COMMIT_FREQUENCY" != "manual" ]]; then echo "Commit after each $(if [[ "$COMMIT_FREQUENCY" == "phase" ]]; then echo "phase"; else echo "feature"; fi) with detailed messages."; fi) Display '<SPARC-COMPLETE>' when the entire development lifecycle is finished. |
|
|
" \ |
|
|
--allowedTools "$allowed_tools" \ |
|
|
$claude_flags |
|
|
} |
|
|
|
|
|
# Execute main function with all arguments |
|
|
main "$@" |
|
|
|
ruvnet revised this gist