@meltstudio/meltctl 2.4.1 → 4.0.0

package/templates/cursor-commands/melt-implement.md

@@ -1,43 +0,0 @@
----
-description: Execute implementation using Melt development standards and domain-driven architecture
----
-
-You are implementing a feature following Melt's domain-driven development process. Follow these steps:
-
-1. **Load Context**:
-   - Read `.melt/memory/context.md` for project context and requirements
-   - Check `.melt/outputs/plans/` for any existing implementation plans
-   - Review relevant domain structure in `src/domains/` if it exists
-
-2. **Architecture Compliance**:
-   - Follow React 2025 standards (functional components, hooks, TypeScript strict)
-   - Use domain-driven design with clear separation of concerns
-   - Implement server components by default, client components when needed
-   - Use Zod for all data validation
-   - Follow Tailwind CSS for styling
-
-3. **Implementation Process**:
-   - Create/update domain structures under `src/domains/[domain]/`
-   - Implement components in `src/domains/[domain]/components/`
-   - Add business logic in `src/domains/[domain]/hooks/` and `src/domains/[domain]/services/`
-   - Create types in `src/domains/[domain]/types/`
-   - Add tests in `src/domains/[domain]/__tests__/`
-
-4. **Quality Standards**:
-   - Ensure 80% test coverage minimum
-   - Use TypeScript strict mode
-   - Add proper JSDoc documentation
-   - Follow atomic commit principles
-   - No debugging code in commits
-
-5. **Documentation**:
-   - Update `.melt/memory/context.md` with implementation details
-   - Save implementation notes to `.melt/outputs/implementations/[timestamp].md`
-   - Update relevant README files if needed
-
-6. **Testing**:
-   - Write unit tests for all business logic
-   - Add integration tests for complex workflows
-   - Ensure all tests pass before completing
-
-Remember: Focus on clean, maintainable code that follows our established patterns and domain boundaries.

package/templates/cursor-commands/melt-plan.md

@@ -1,60 +0,0 @@
----
-description: Create implementation plan with User Story and RFC validation following Melt's domain-driven architecture standards
-scripts:
-  sh: .melt/scripts/sh/get-plan-context.sh --json
-  ps: .melt/scripts/ps/get-plan-context.ps1 -Json
----
-
-Create a comprehensive implementation plan for the requested feature. Follow these steps:
-
-1. **Collect Requirements**:
-   - Run `{SCRIPT}` from the project root and parse JSON for USER_STORY, RFC, ISSUE_ID, PLAN_FILE, and PROJECT_ROOT
-   - If script fails, prompt manually for User Story and RFC
-   - Validate that both User Story and RFC are complete and actionable
-
-2. **Analyze Requirements**:
-   - Analyze the provided User Story for clear acceptance criteria and user value
-   - Review the RFC for technical decisions, architecture, and constraints
-   - Read `.melt/memory/context.md` for additional project context
-   - Identify the target domain(s) this feature belongs to
-   - Determine integration points with existing domains
-
-3. **Architecture Planning**:
-   - Design domain structure following our patterns:
-     ```
-     src/domains/[domain]/
-     ├── components/          # React components
-     ├── hooks/              # Custom hooks for business logic
-     ├── services/           # API calls and external integrations
-     ├── types/              # TypeScript types and Zod schemas
-     ├── utils/              # Domain-specific utilities
-     └── __tests__/          # Domain tests
-     ```
-   - Plan component hierarchy and state management
-   - Design data flow and API integration points
-
-4. **Technical Decisions**:
-   - Choose appropriate React patterns (server vs client components)
-   - Plan Zod schemas for data validation
-   - Design TypeScript interfaces and types
-   - Plan testing strategy (unit, integration, e2e)
-
-5. **Implementation Strategy**:
-   - Break down into atomic, testable units
-   - Identify dependencies and execution order
-   - Plan for error handling and edge cases
-   - Consider accessibility and performance requirements
-
-6. **Create Detailed Plan**:
-   - List specific files to create/modify
-   - Define component interfaces and props
-   - Specify API endpoints and data contracts
-   - Plan test cases and coverage targets
-
-7. **Save Planning Output**:
-   - Save comprehensive plan to the PLAN_FILE path provided by the script
-   - Include User Story and RFC as context sections in the plan
-   - Update `.melt/memory/context.md` with planning decisions and issue reference
-   - Create task breakdown for implementation with clear dependencies
-
-Focus on maintainable, testable code that follows our domain-driven architecture principles.

package/templates/cursor-commands/melt-pr.md

@@ -1,53 +0,0 @@
----
-description: Create comprehensive pull request with proper description and metadata
----
-
-Create a detailed pull request following Melt's standards for code review and deployment:
-
-1. **Gather Context**:
-   - Read `.melt/outputs/plans/` for implementation plan details
-   - Review `.melt/outputs/implementations/` for implementation notes
-   - Check `.melt/memory/context.md` for project context
-   - Identify related Linear story and RFC references
-
-2. **PR Description Structure**:
-   - **Summary**: Brief description of what was implemented
-   - **Changes**: Bulleted list of specific changes made
-   - **Testing**: How the changes were tested (unit, integration, manual)
-   - **Screenshots**: For UI changes, include before/after images
-   - **Linear Story**: Link to Linear story and requirements
-   - **RFC Reference**: Link to relevant RFC section if applicable
-
-3. **PR Metadata**:
-   - Add appropriate labels (feature, bugfix, docs, etc.)
-   - Assign reviewers based on affected domains
-   - Set milestone if applicable
-   - Link to related issues or PRs
-
-4. **Code Review Preparation**:
-   - Ensure all tests pass
-   - Run linting and type checking
-   - Verify accessibility compliance
-   - Check performance impact
-   - Validate security considerations
-
-5. **Deployment Readiness**:
-   - Document any environment variable changes
-   - Note database migration requirements
-   - Include feature flag configurations
-   - Specify rollback procedures if needed
-
-6. **Quality Checklist**:
-   - [ ] Code follows domain architecture patterns
-   - [ ] Tests have adequate coverage (80%+)
-   - [ ] Documentation updated
-   - [ ] No debugging code committed
-   - [ ] TypeScript strict mode compliance
-   - [ ] Performance considerations addressed
-
-7. **Save PR Information**:
-   - Create PR with comprehensive description
-   - Save PR details to `.melt/outputs/implementations/[timestamp]-pr.md`
-   - Update `.melt/memory/context.md` with PR status
-
-Focus on clear communication and thorough preparation for efficient code review.

package/templates/cursor-commands/melt-review.md

@@ -1,43 +0,0 @@
----
-description: Review code following Melt's quality standards and architecture compliance
----
-
-Perform a comprehensive code review following Melt's standards:
-
-1. **Architecture Review**:
-   - Verify domain-driven design compliance
-   - Check proper separation of concerns
-   - Validate component placement within domain structure
-   - Review data flow and state management patterns
-
-2. **Code Quality**:
-   - TypeScript strict mode compliance
-   - Proper error handling and edge cases
-   - Performance considerations (memo, useMemo, useCallback)
-   - Accessibility compliance (ARIA, semantic HTML)
-
-3. **Testing Coverage**:
-   - Unit tests for business logic (80% minimum)
-   - Integration tests for complex workflows
-   - Test quality and maintainability
-   - Mock strategies and test isolation
-
-4. **Documentation**:
-   - JSDoc comments for public APIs
-   - README updates for new features
-   - Architecture decision records when applicable
-   - Code comments for complex business logic
-
-5. **Security & Best Practices**:
-   - Input validation with Zod schemas
-   - XSS prevention in dynamic content
-   - Proper authentication/authorization patterns
-   - Environment variable usage
-
-6. **Review Output**:
-   - Document findings in `.melt/outputs/reviews/[timestamp]-review.md`
-   - Categorize issues by severity (critical, major, minor)
-   - Provide specific recommendations and examples
-   - Update `.melt/memory/context.md` with lessons learned
-
-Focus on constructive feedback that improves code quality and team knowledge.

package/templates/cursor-commands/melt-test-plan.md

@@ -1,50 +0,0 @@
----
-description: Generate comprehensive test strategy and test files based on implementation plan
----
-
-Create a comprehensive testing strategy and generate test files following Melt's testing standards:
-
-1. **Load Implementation Context**:
-   - Read `.melt/outputs/plans/` for the current implementation plan
-   - Review `.melt/memory/context.md` for project testing patterns
-   - Analyze existing test files in `src/domains/[domain]/__tests__/`
-
-2. **Test Strategy Design**:
-   - **Unit Tests**: Test individual components, hooks, and utilities
-   - **Integration Tests**: Test component interactions and data flow
-   - **API Tests**: Test service layer and external integrations
-   - **Accessibility Tests**: Ensure WCAG compliance
-   - **Performance Tests**: Validate rendering and interaction performance
-
-3. **Test File Generation**:
-   - Create test files following domain structure:
-     ```
-     src/domains/[domain]/__tests__/
-     ├── components/          # Component tests
-     ├── hooks/              # Hook tests
-     ├── services/           # Service/API tests
-     └── utils/              # Utility function tests
-     ```
-   - Use React Testing Library for component tests
-   - Use @testing-library/react-hooks for hook tests
-   - Mock external dependencies appropriately
-
-4. **Testing Patterns**:
-   - Follow TDD approach - write tests before implementation
-   - Test behavior, not implementation details
-   - Use meaningful test descriptions and organize with describe blocks
-   - Include edge cases and error scenarios
-   - Ensure accessibility testing with @testing-library/jest-dom
-
-5. **Test Coverage Strategy**:
-   - Target 80% minimum coverage for new code
-   - Focus on critical business logic and user flows
-   - Test error handling and edge cases
-   - Validate prop types and component contracts
-
-6. **Save Test Plan**:
-   - Document test strategy in `.melt/outputs/plans/[timestamp]-test-plan.md`
-   - Create test files in appropriate domain directories
-   - Update `.melt/memory/context.md` with testing decisions
-
-Focus on creating comprehensive, maintainable tests that validate both functionality and user experience.