myaidev-method 0.2.4 → 0.2.6

package/src/templates/gemini/commands/myai-dev-architect.toml

@@ -0,0 +1,64 @@
+prompt = """
+Design scalable system architecture using MyAIDev Method's systematic approach for: {{args}}
+
+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
+
+## Usage Patterns
+
+You can specify:
+- 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/`)
+
+## Examples
+
+### Design New System
+"Design real-time chat application for 10k concurrent users"
+
+### Improve Existing Architecture
+"Review current e-commerce platform and propose performance improvements"
+
+### Specify Technology Stack
+"Design microservices architecture --tech-stack node,kubernetes,mongodb,redis"
+
+## 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/gemini/commands/myai-dev-code.toml

@@ -0,0 +1,75 @@
+prompt = """
+Implement features and write production-ready code using MyAIDev Method's systematic approach for: {{args}}
+
+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
+
+## Usage Patterns
+
+You can specify:
+- 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/`)
+
+## Examples
+
+### Implement Authentication
+"Implement JWT-based authentication with refresh tokens"
+
+### Build API Endpoints
+"Create REST API endpoints for user management"
+
+### Refactor Existing Code
+"Refactor payment processing to improve testability and error handling"
+
+### Test-Driven Development
+"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/gemini/commands/myai-dev-docs.toml

@@ -0,0 +1,76 @@
+prompt = """
+Generate comprehensive documentation using MyAIDev Method's systematic approach for: {{args}}
+
+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
+
+## Usage Patterns
+
+You can specify:
+- 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/`)
+
+## Examples
+
+### API Documentation
+"Document REST API endpoints for user management"
+
+### User Guide
+"Create user guide for authentication system --type user-guide"
+
+### Architecture Documentation
+"Document system architecture and design decisions --type architecture"
+
+### OpenAPI Specification
+"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/gemini/commands/myai-dev-review.toml

@@ -0,0 +1,78 @@
+prompt = """
+Perform comprehensive code review using MyAIDev Method's systematic approach for: {{args}}
+
+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
+
+## Usage Patterns
+
+You can specify:
+- 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/`)
+
+## Examples
+
+### General Code Review
+"Review user authentication module for quality and security"
+
+### Security-Focused Review
+"Security audit of payment processing --security"
+
+### Performance Review
+"Review database layer for performance bottlenecks --performance"
+
+### Pre-Production 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/gemini/commands/myai-dev-test.toml

@@ -0,0 +1,77 @@
+prompt = """
+Write and execute comprehensive tests using MyAIDev Method's systematic approach for: {{args}}
+
+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
+
+## Usage Patterns
+
+You can specify:
+- 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/`)
+
+## Examples
+
+### Unit Testing
+"Write unit tests for authentication module"
+
+### Integration Testing
+"Test complete checkout workflow --integration"
+
+### Coverage Improvement
+"Improve coverage for payment processing --coverage"
+
+### Framework-Specific
+"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/gemini/commands/myai-docusaurus-publish.toml

@@ -0,0 +1,63 @@
+prompt = """
+Publish markdown content to Docusaurus static site generator with automatic git workflow: {{args}}
+
+Invoke the Docusaurus publishing agent to transform content and deploy via git.
+
+## Task
+Add markdown content to Docusaurus site and commit via git.
+
+## Process
+
+1. **Read the markdown file** from the path provided
+2. **Determine content type** (docs, blog, or pages)
+3. **Validate frontmatter** for Docusaurus compatibility
+4. **Copy file to appropriate directory**:
+   - Docs: `docs/` or `versioned_docs/`
+   - Blog: `blog/`
+   - Pages: `src/pages/`
+5. **Update navigation** (for docs) if needed
+6. **Commit and push** via git workflow
+
+## Parameters
+
+When parsing {{args}}, look for:
+- File path (required): Path to markdown file
+- --type: docs (default), blog, or pages
+- --project: Docusaurus project path (default: current directory)
+- --branch: Git branch name (default: main)
+- --no-push: Commit but don't push
+- --dry-run: Validate without publishing
+
+## 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
+```
+
+## Prerequisites
+
+Requires Docusaurus project with:
+- docusaurus.config.js
+- Git repository initialized
+- Appropriate directories (docs/, blog/, src/pages/)
+
+## Git Workflow
+
+1. Check for uncommitted changes
+2. Create feature branch (optional)
+3. Add the new file
+4. Commit with descriptive message
+5. Push to remote (unless --no-push)
+6. Report git status and URLs
+"""