myaidev-method 0.2.4 → 0.2.6

package/src/templates/codex/commands/myai-dev-architect.md

@@ -0,0 +1,69 @@
+# System Architecture Design
+
+Design scalable system architecture using MyAIDev Method's systematic approach: $ARGUMENTS
+
+Invoke the MyAIDev Architect agent to create comprehensive system designs with architecture diagrams, API specifications, and technology recommendations.
+
+## What It Does
+
+The architect agent will:
+1. Analyze requirements and constraints
+2. Design high-level system architecture
+3. Create component diagrams with Mermaid
+4. Define API specifications and contracts
+5. Plan data models and flows
+6. Recommend appropriate technologies
+7. Document security patterns
+8. Consider scalability and performance
+
+## Output
+
+Creates `.myaidev-method/sparc/architecture.md` containing:
+- System overview and requirements
+- Architecture diagrams (Mermaid format)
+- Component specifications
+- API contracts and endpoints
+- Data models and schemas
+- Technology stack recommendations
+- Security considerations
+- Scalability planning
+- Deployment architecture
+
+## Examples
+
+### Design New System
+```bash
+/myai-dev-architect "Design real-time chat application for 10k concurrent users"
+```
+
+### Improve Existing Architecture
+```bash
+/myai-dev-architect "Review current e-commerce platform and propose performance improvements"
+```
+
+### Specify Technology Stack
+```bash
+/myai-dev-architect "Design microservices architecture" --tech-stack "node,kubernetes,mongodb,redis"
+```
+
+## Options
+
+- Task description (required) - Clear description of the architecture task
+- `--existing-code` - Analyze existing codebase before designing
+- `--tech-stack <stack>` - Specify preferred technology stack (e.g., "node,postgres,redis")
+- `--output-dir <path>` - Custom output directory (default: `.myaidev-method/sparc/`)
+
+## Integration with SPARC Workflow
+
+This is **Phase 1** of the MyAIDev Method SPARC workflow:
+- **Current Phase**: Architecture
+- **Next Phase**: Implementation (`/myai-dev-code`)
+- **Outputs**: Architecture specifications for implementation
+
+## MyAIDev Method Standards
+
+All outputs follow MyAIDev Method conventions:
+- Saved to `.myaidev-method/sparc/` directory
+- Version controlled (git-friendly format)
+- Includes visual diagrams (Mermaid)
+- Documents all design decisions

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

@@ -0,0 +1,82 @@
+# Feature Implementation
+
+Implement features and write production-ready code using MyAIDev Method's systematic approach: $ARGUMENTS
+
+Invoke the MyAIDev Coder agent to implement features based on architecture specifications, following best practices and clean code principles.
+
+## 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
+```
+
+## 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/`)
+
+## 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/codex/commands/myai-dev-docs.md

@@ -0,0 +1,83 @@
+# Comprehensive Documentation
+
+Generate comprehensive documentation using MyAIDev Method's systematic approach: $ARGUMENTS
+
+Invoke the MyAIDev Documenter agent to create API documentation, user guides, architecture docs, and technical specifications.
+
+## 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
+```
+
+## 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/`)
+
+## 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/codex/commands/myai-dev-review.md

@@ -0,0 +1,85 @@
+# Code Quality Review
+
+Perform comprehensive code review using MyAIDev Method's systematic approach: $ARGUMENTS
+
+Invoke the MyAIDev Reviewer agent to analyze code quality, security vulnerabilities, performance issues, and best practices compliance.
+
+## 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"
+```
+
+## 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/`)
+
+## 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/codex/commands/myai-dev-test.md

@@ -0,0 +1,84 @@
+# Comprehensive Testing
+
+Write and execute comprehensive tests using MyAIDev Method's systematic approach: $ARGUMENTS
+
+Invoke the MyAIDev Tester agent to create unit tests, integration tests, and validate code quality with coverage analysis.
+
+## 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
+```
+
+## 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/`)
+
+## 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/codex/commands/myai-docusaurus-publish.md

@@ -0,0 +1,42 @@
+# Docusaurus Content Publisher
+
+Publish markdown content to Docusaurus static site generator with automatic git workflow: $ARGUMENTS
+
+Invoke the Docusaurus publishing agent to transform content and deploy via git.
+
+## Usage Examples
+
+```bash
+/myai-docusaurus-publish "guide.md"
+/myai-docusaurus-publish "post.md" --type blog
+/myai-docusaurus-publish "api.md" --project ./docs-site --branch develop
+```
+
+## Options
+
+- `--type docs|blog|pages` - Content type (default: docs)
+- `--project <path>` - Docusaurus project path
+- `--branch <name>` - Git branch (default: main)
+- `--no-push` - Commit but don't push
+- `--dry-run` - Validate without publishing
+
+## Prerequisites
+
+Docusaurus project with docusaurus.config.js and git repository.
+
+## Examples
+
+### Publish documentation
+```
+/myai-docusaurus-publish "getting-started.md"
+```
+
+### Publish blog post
+```
+/myai-docusaurus-publish "my-story.md" --type blog
+```
+
+### Custom project
+```
+/myai-docusaurus-publish "guide.md" --project ~/my-docs --branch staging
+```