myaidev-method 0.2.2 → 0.2.4

package/src/templates/claude/commands/myai-dev-code.md

@@ -0,0 +1,93 @@
+---
+name: myai-dev-code
+description: Implement features with MyAIDev Method
+---
+
+Implement features and write production-ready code using MyAIDev Method's systematic approach.
+
+Invoke the MyAIDev Coder agent to implement features based on architecture specifications, following best practices and clean code principles.
+
+## Usage
+
+```bash
+/myai-dev-code "Implement user authentication"
+/myai-dev-code "Build payment processing system"
+/myai-dev-code "Refactor database queries for performance"
+```
+
+## Options
+
+- Task description (required) - Clear description of the implementation task
+- `--architecture <file>` - Path to architecture specification (default: `.myaidev-method/sparc/architecture.md`)
+- `--test-driven` - Use TDD approach (write tests first)
+- `--output-dir <path>` - Custom output directory (default: `.myaidev-method/sparc/code-output/`)
+
+## What It Does
+
+The coder agent will:
+1. Read architecture specifications
+2. Plan implementation approach
+3. Write clean, modular code
+4. Follow SOLID principles
+5. Implement error handling
+6. Add security measures
+7. Include inline documentation
+8. Create basic tests
+
+## Output
+
+Creates implementation files in `.myaidev-method/sparc/code-output/`:
+- Feature implementation code
+- Utility functions and helpers
+- Configuration files
+- Basic unit tests
+- Implementation notes
+
+## Code Quality Standards
+
+All code follows:
+- **SOLID Principles**: Single responsibility, modularity
+- **Clean Code**: DRY, KISS, YAGNI
+- **Security**: Input validation, error handling, no secrets
+- **Testing**: Testable code with >80% coverage target
+- **Documentation**: Clear comments and inline docs
+
+## Examples
+
+### Implement Authentication
+```bash
+/myai-dev-code "Implement JWT-based authentication with refresh tokens"
+```
+
+### Build API Endpoints
+```bash
+/myai-dev-code "Create REST API endpoints for user management"
+```
+
+### Refactor Existing Code
+```bash
+/myai-dev-code "Refactor payment processing to improve testability and error handling"
+```
+
+### Test-Driven Development
+```bash
+/myai-dev-code "Implement order checkout workflow" --test-driven
+```
+
+## Integration with SPARC Workflow
+
+This is **Phase 2** of the MyAIDev Method SPARC workflow:
+- **Previous Phase**: Architecture (`/myai-dev-architect`)
+- **Current Phase**: Implementation
+- **Next Phase**: Testing (`/myai-dev-test`)
+- **Inputs**: Architecture specifications
+- **Outputs**: Production-ready code
+
+## MyAIDev Method Standards
+
+All code follows MyAIDev Method conventions:
+- Modular and maintainable
+- Secure by design
+- Well-documented
+- Testable architecture
+- Follows project patterns

package/src/templates/claude/commands/myai-dev-docs.md

@@ -0,0 +1,94 @@
+---
+name: myai-dev-docs
+description: Generate comprehensive documentation with MyAIDev Method
+---
+
+Generate comprehensive documentation using MyAIDev Method's systematic approach.
+
+Invoke the MyAIDev Documenter agent to create API documentation, user guides, architecture docs, and technical specifications.
+
+## Usage
+
+```bash
+/myai-dev-docs "Document authentication API"
+/myai-dev-docs "Create user guide for checkout flow"
+/myai-dev-docs "Generate API reference for payment module"
+```
+
+## Options
+
+- Task description (required) - Clear description of documentation requirements
+- `--type <type>` - Documentation type: api, user-guide, architecture, technical (default: api)
+- `--format <format>` - Output format: markdown, html, openapi, swagger (default: markdown)
+- `--output-dir <path>` - Custom output directory (default: `.myaidev-method/sparc/documentation/`)
+
+## What It Does
+
+The documenter agent will:
+1. Analyze code structure and interfaces
+2. Extract API contracts and endpoints
+3. Generate comprehensive documentation
+4. Create usage examples and code samples
+5. Document edge cases and error handling
+6. Generate visual diagrams (architecture, data flow)
+7. Create searchable API reference
+8. Produce user-friendly guides
+
+## Output
+
+Creates documentation files in `.myaidev-method/sparc/documentation/`:
+- API reference documentation
+- User guides and tutorials
+- Architecture documentation
+- Code examples and snippets
+- Mermaid diagrams
+- OpenAPI/Swagger specs (if applicable)
+
+## Documentation Standards
+
+All documentation follows:
+- **Clarity**: Simple language, clear examples, visual aids
+- **Completeness**: All public APIs documented, edge cases covered
+- **Accuracy**: Code examples tested, documentation synchronized with code
+- **Accessibility**: Multiple formats, searchable, well-organized
+- **Maintenance**: Version-controlled, update procedures documented
+
+## Examples
+
+### API Documentation
+```bash
+/myai-dev-docs "Document REST API endpoints for user management"
+```
+
+### User Guide
+```bash
+/myai-dev-docs "Create user guide for authentication system" --type user-guide
+```
+
+### Architecture Documentation
+```bash
+/myai-dev-docs "Document system architecture and design decisions" --type architecture
+```
+
+### OpenAPI Specification
+```bash
+/myai-dev-docs "Generate OpenAPI spec for payment API" --format openapi
+```
+
+## Integration with SPARC Workflow
+
+This is **Phase 5** of the MyAIDev Method SPARC workflow:
+- **Previous Phase**: Review (`/myai-dev-review`)
+- **Current Phase**: Documentation
+- **Final Phase**: Complete
+- **Inputs**: Reviewed and validated code
+- **Outputs**: Comprehensive documentation suite
+
+## MyAIDev Method Standards
+
+All documentation follows MyAIDev Method conventions:
+- Saved to `.myaidev-method/sparc/documentation/` directory
+- Version controlled (Markdown format)
+- Includes visual diagrams (Mermaid)
+- Code examples tested and verified
+- Multiple audience levels supported

package/src/templates/claude/commands/myai-dev-review.md

@@ -0,0 +1,96 @@
+---
+name: myai-dev-review
+description: Review code quality and security with MyAIDev Method
+---
+
+Perform comprehensive code review using MyAIDev Method's systematic approach.
+
+Invoke the MyAIDev Reviewer agent to analyze code quality, security vulnerabilities, performance issues, and best practices compliance.
+
+## Usage
+
+```bash
+/myai-dev-review "Review authentication implementation"
+/myai-dev-review "Security audit for payment processing"
+/myai-dev-review "Performance review of database queries"
+```
+
+## Options
+
+- Task description (required) - Clear description of review scope
+- `--security` - Focus on security analysis (OWASP Top 10)
+- `--performance` - Focus on performance optimization
+- `--output-dir <path>` - Custom output directory (default: `.myaidev-method/sparc/`)
+
+## What It Does
+
+The reviewer agent will:
+1. Analyze code quality and maintainability
+2. Check for security vulnerabilities (OWASP Top 10)
+3. Review performance and optimization opportunities
+4. Validate best practices compliance
+5. Identify code smells and anti-patterns
+6. Assess technical debt
+7. Provide actionable recommendations
+8. Generate comprehensive review report
+
+## Output
+
+Creates `.myaidev-method/sparc/review-report.md` containing:
+- Executive summary with quality scores
+- Critical/High/Medium/Low priority issues
+- Security analysis (OWASP Top 10 compliance)
+- Performance metrics and bottlenecks
+- Code quality assessment
+- Technical debt evaluation
+- Testing recommendations
+- Actionable improvement plan
+
+## Review Standards
+
+All reviews cover:
+- **Code Quality**: Complexity, readability, maintainability
+- **Security**: OWASP Top 10, vulnerability patterns
+- **Performance**: Algorithm complexity, resource management
+- **Best Practices**: SOLID principles, framework standards
+- **Technical Debt**: Assessment, prioritization, remediation
+
+## Examples
+
+### General Code Review
+```bash
+/myai-dev-review "Review user authentication module for quality and security"
+```
+
+### Security-Focused Review
+```bash
+/myai-dev-review "Security audit of payment processing" --security
+```
+
+### Performance Review
+```bash
+/myai-dev-review "Review database layer for performance bottlenecks" --performance
+```
+
+### Pre-Production Review
+```bash
+/myai-dev-review "Final review before production deployment"
+```
+
+## Integration with SPARC Workflow
+
+This is **Phase 4** of the MyAIDev Method SPARC workflow:
+- **Previous Phase**: Testing (`/myai-dev-test`)
+- **Current Phase**: Review
+- **Next Phase**: Documentation (`/myai-dev-docs`)
+- **Inputs**: Implemented and tested code
+- **Outputs**: Comprehensive review report with recommendations
+
+## MyAIDev Method Standards
+
+All reviews follow MyAIDev Method conventions:
+- Evidence-based analysis
+- Actionable recommendations
+- Priority-based issue tracking
+- Security-first mindset
+- Performance optimization focus

package/src/templates/claude/commands/myai-dev-test.md

@@ -0,0 +1,95 @@
+---
+name: myai-dev-test
+description: Write comprehensive tests with MyAIDev Method
+---
+
+Write and execute comprehensive tests using MyAIDev Method's systematic approach.
+
+Invoke the MyAIDev Tester agent to create unit tests, integration tests, and validate code quality with coverage analysis.
+
+## Usage
+
+```bash
+/myai-dev-test "Test authentication system"
+/myai-dev-test "Create integration tests for checkout flow"
+/myai-dev-test "Improve test coverage for payment module"
+```
+
+## Options
+
+- Task description (required) - Clear description of testing requirements
+- `--coverage` - Generate coverage report
+- `--integration` - Focus on integration tests
+- `--framework <name>` - Specify testing framework (jest, mocha, pytest, etc.)
+- `--output-dir <path>` - Custom output directory (default: `.myaidev-method/sparc/test-results/`)
+
+## What It Does
+
+The tester agent will:
+1. Analyze code to be tested
+2. Create comprehensive test suites
+3. Write unit tests for components
+4. Write integration tests for workflows
+5. Generate test coverage reports
+6. Identify untested edge cases
+7. Validate quality gates
+8. Provide improvement recommendations
+
+## Output
+
+Creates test files in `.myaidev-method/sparc/test-results/`:
+- Unit test files
+- Integration test files
+- Test report with metrics
+- Coverage report
+- Quality gates validation
+- Recommendations for improvement
+
+## Testing Standards
+
+All tests follow:
+- **Coverage Requirements**: 80%+ for critical paths, 60%+ overall
+- **Test Patterns**: AAA (Arrange, Act, Assert)
+- **Edge Cases**: Boundary conditions, error scenarios
+- **Integration**: End-to-end workflow validation
+- **Quality Gates**: Pre-commit, pre-merge, pre-deployment
+
+## Examples
+
+### Unit Testing
+```bash
+/myai-dev-test "Write unit tests for authentication module"
+```
+
+### Integration Testing
+```bash
+/myai-dev-test "Test complete checkout workflow" --integration
+```
+
+### Coverage Improvement
+```bash
+/myai-dev-test "Improve coverage for payment processing" --coverage
+```
+
+### Framework-Specific
+```bash
+/myai-dev-test "Create pytest tests for API endpoints" --framework pytest
+```
+
+## Integration with SPARC Workflow
+
+This is **Phase 3** of the MyAIDev Method SPARC workflow:
+- **Previous Phase**: Implementation (`/myai-dev-code`)
+- **Current Phase**: Testing
+- **Next Phase**: Review (`/myai-dev-review`)
+- **Inputs**: Implemented code
+- **Outputs**: Comprehensive test suite and coverage report
+
+## MyAIDev Method Standards
+
+All tests follow MyAIDev Method conventions:
+- Comprehensive coverage (80%+ target)
+- Clear test naming and organization
+- Fast execution (<5s for unit tests)
+- Isolated and independent tests
+- Quality gate validation

package/src/templates/claude/commands/myai-sparc-workflow.md

@@ -0,0 +1,196 @@
+---
+name: myai-sparc-workflow
+description: Execute complete SPARC development workflow with MyAIDev Method
+---
+
+Execute the complete 5-phase SPARC development workflow using MyAIDev Method's systematic approach.
+
+Orchestrates all development agents in sequence: Architecture → Implementation → Testing → Review → Documentation
+
+## Usage
+
+```bash
+/myai-sparc-workflow "Build user authentication system"
+/myai-sparc-workflow "Create payment processing module"
+/myai-sparc-workflow "Implement real-time chat feature"
+```
+
+## Options
+
+- Task description (required) - Clear description of the complete feature/system to build
+- `--phases <phases>` - Specific phases to run (comma-separated): architecture,implementation,testing,review,documentation
+- `--tech-stack <stack>` - Technology preferences (e.g., "node,postgres,redis")
+- `--output-dir <path>` - Custom output directory (default: `.myaidev-method/sparc/`)
+- `--test-framework <name>` - Testing framework preference (jest, mocha, pytest, etc.)
+- `--skip-phase <phase>` - Skip specific phase (use with caution)
+
+## SPARC Workflow Phases
+
+The workflow executes these phases in sequence:
+
+### 1. **Specification & Architecture** (`/myai-dev-architect`)
+- Requirements analysis
+- System design with Mermaid diagrams
+- API specifications
+- Data modeling
+- Technology recommendations
+- Security planning
+
+**Output**: `.myaidev-method/sparc/architecture.md`
+
+### 2. **Pseudocode & Implementation** (`/myai-dev-code`)
+- Feature implementation based on architecture
+- SOLID principles application
+- Security best practices
+- Error handling
+- Inline documentation
+
+**Output**: `.myaidev-method/sparc/code-output/`
+
+### 3. **Architecture Validation & Testing** (`/myai-dev-test`)
+- Unit test creation
+- Integration test development
+- Coverage analysis (80%+ target)
+- Quality gate validation
+- Test execution
+
+**Output**: `.myaidev-method/sparc/test-results/`
+
+### 4. **Refinement & Review** (`/myai-dev-review`)
+- Code quality analysis
+- Security audit (OWASP Top 10)
+- Performance review
+- Best practices validation
+- Technical debt assessment
+
+**Output**: `.myaidev-method/sparc/review-report.md`
+
+### 5. **Completion & Documentation** (`/myai-dev-docs`)
+- API documentation
+- User guides
+- Architecture documentation
+- Code examples
+- Deployment guides
+
+**Output**: `.myaidev-method/sparc/documentation/`
+
+## What It Does
+
+The SPARC workflow orchestrator will:
+1. Initialize `.myaidev-method/sparc/` directory structure
+2. Create task tracking files in `.myaidev-method/tasks/`
+3. Execute each phase sequentially with proper handoffs
+4. Validate phase outputs before proceeding
+5. Generate comprehensive workflow summary
+6. Track progress and results
+7. Handle errors with graceful phase rollback
+8. Produce production-ready deliverables
+
+## Directory Structure Created
+
+```
+.myaidev-method/
+├── sparc/
+│   ├── architecture.md              # Phase 1 output
+│   ├── code-output/                 # Phase 2 output
+│   │   ├── src/
+│   │   └── ...
+│   ├── test-results/                # Phase 3 output
+│   │   ├── unit/
+│   │   ├── integration/
+│   │   └── coverage-report.md
+│   ├── review-report.md             # Phase 4 output
+│   └── documentation/               # Phase 5 output
+│       ├── api/
+│       ├── user-guide/
+│       └── architecture/
+├── tasks/
+│   └── workflow_[timestamp].json
+└── workflows/
+    └── sparc_[timestamp].json
+```
+
+## Output
+
+Creates a comprehensive workflow summary in `.myaidev-method/workflows/`:
+- Complete workflow execution log
+- Phase-by-phase results
+- Quality metrics and coverage
+- Review findings and recommendations
+- Documentation index
+- Next steps and maintenance guide
+
+## Examples
+
+### Complete Feature Development
+```bash
+/myai-sparc-workflow "Build JWT-based authentication system with refresh tokens"
+```
+
+### Specific Technology Stack
+```bash
+/myai-sparc-workflow "Create e-commerce checkout flow" --tech-stack "react,node,stripe,postgres"
+```
+
+### Run Specific Phases
+```bash
+/myai-sparc-workflow "Refactor payment module" --phases "architecture,review,documentation"
+```
+
+### Custom Test Framework
+```bash
+/myai-sparc-workflow "Build API endpoints" --test-framework pytest
+```
+
+## Workflow Benefits
+
+- **Systematic Approach**: No missed steps, comprehensive coverage
+- **Quality Assurance**: Built-in review and testing at every phase
+- **Documentation**: Complete documentation generated automatically
+- **Traceability**: Full workflow history and decision tracking
+- **Best Practices**: SOLID, Clean Code, Security embedded in process
+- **Reproducible**: Consistent results across projects and teams
+
+## Integration with MyAIDev Method
+
+This command orchestrates the complete MyAIDev Method development workflow:
+- **Methodology**: SPARC (Specification, Pseudocode, Architecture, Refinement, Completion)
+- **Agent Coordination**: Sequential execution with file-based handoffs
+- **Quality Gates**: Validation at each phase transition
+- **Outputs**: Production-ready code with comprehensive documentation
+
+## Quality Standards
+
+All phases follow MyAIDev Method standards:
+- **Code Quality**: SOLID principles, Clean Code, DRY/KISS/YAGNI
+- **Testing**: 80%+ coverage, integration tests, quality gates
+- **Security**: OWASP Top 10 compliance, input validation, error handling
+- **Documentation**: API docs, user guides, architecture specifications
+- **Performance**: Optimization analysis, scalability planning
+
+## Error Handling
+
+The workflow includes robust error handling:
+- **Phase Validation**: Verify outputs before proceeding to next phase
+- **Graceful Degradation**: Continue with warnings when possible
+- **Rollback Support**: Restore previous state on critical failures
+- **Error Reports**: Detailed error logs in `.myaidev-method/workflows/`
+- **Manual Override**: Skip or retry phases as needed
+
+## Next Steps After Completion
+
+1. **Review Outputs**: Examine all generated artifacts in `.myaidev-method/sparc/`
+2. **Address Findings**: Review phase 4 report and address issues
+3. **Integration**: Integrate code into your project structure
+4. **Testing**: Run final integration tests
+5. **Deployment**: Follow deployment guide in documentation
+6. **Maintenance**: Use generated documentation for ongoing development
+
+## MyAIDev Method Philosophy
+
+The SPARC workflow embodies MyAIDev Method principles:
+- **Specification First**: Clear requirements before implementation
+- **Architecture Planning**: Design before coding
+- **Testing Built-In**: Quality from the start
+- **Continuous Review**: Iterative refinement
+- **Documentation Integral**: Knowledge preservation