metacoding 1.0.0

package/templates/python/files/release.instructions.md

@@ -0,0 +1,72 @@
+---
+description: "Step-by-step release process automation"
+applyTo: "package.json"
+---
+
+# Release Process Checklist
+
+## Pre-Release Validation
+1. **Test Suite:** Verify all tests pass: `npm test`
+2. **Build Verification:** Ensure clean build without errors: `npm run build`
+3. **Linting:** Check code quality standards: `npm run lint`
+4. **Dependencies:** Review and update dependencies if needed
+5. **Security Audit:** Run security audit: `npm audit`
+
+## Version Management
+1. **Semantic Versioning:** Update version in package.json following SemVer:
+   - **MAJOR:** Breaking changes (X.0.0)
+   - **MINOR:** New features, backward compatible (0.X.0)
+   - **PATCH:** Bug fixes, backward compatible (0.0.X)
+2. **Version Consistency:** Ensure version matches across all relevant files
+3. **Breaking Changes:** Document breaking changes prominently in changelog
+
+## Documentation Updates
+1. **README.md Updates:**
+   - Update version badges to match package.json version
+   - Refresh installation instructions if needed
+   - Update feature descriptions for new capabilities
+   - Verify all links and examples work correctly
+2. **API Documentation:** Update API docs for any interface changes
+
+## Changelog Management
+1. **Add New Entry:** Create new section in CHANGELOG.md with:
+   - Release version number (matching package.json)
+   - Release date in YYYY-MM-DD format
+   - Grouped changes by category:
+     - **Added:** New features
+     - **Changed:** Changes in existing functionality
+     - **Deprecated:** Soon-to-be removed features
+     - **Removed:** Now removed features
+     - **Fixed:** Bug fixes
+     - **Security:** Security vulnerability fixes
+2. **Entry Guidelines:**
+   - Keep entries brief but descriptive (1-2 lines per change)
+   - Focus on user impact rather than technical implementation
+   - Reference issue/PR numbers when applicable: `(#123)`
+   - Highlight breaking changes with ⚠️ or **BREAKING:**
+
+## Git Operations
+1. **Commit Changes:** Stage all release-related changes
+2. **Commit Message:** Use format: `chore: bump version to vX.Y.Z`
+3. **Create Tag:** Tag the commit with version number: `git tag vX.Y.Z`
+4. **Push Changes:** Push commits and tags: `git push && git push --tags`
+
+## GitHub Release
+1. **Create Release:** Create GitHub release with tag matching package.json version
+2. **Release Title:** Use format: `vX.Y.Z - [Brief description]`
+3. **Release Notes:** 
+   - Copy relevant sections from CHANGELOG.md
+   - Include installation instructions
+   - Highlight major changes and breaking changes
+   - Thank contributors if applicable
+
+## Post-Release Verification
+1. **Package Registry:** Verify package published correctly (if applicable)
+2. **Installation Test:** Test installation from registry in clean environment
+3. **Documentation Links:** Ensure all documentation links work correctly
+4. **Monitor Issues:** Watch for any immediate issues reported by users
+
+## Rollback Plan
+- **Git Revert:** Know how to revert problematic releases
+- **Package Unpublish:** Understand package registry policies for unpublishing
+- **Communication:** Prepare communication strategy for critical issues

package/templates/python/files/test-runner.instructions.md

@@ -0,0 +1,108 @@
+---
+description: 'Instructions for running and maintaining tests'
+applyTo: 'test/**/*.ts'
+---
+
+# Test Execution Guidelines
+
+## Pre-Commit Testing
+
+- Run all tests before committing changes: `npm test`
+- Ensure tests pass in both development and CI environments
+- Fix failing tests before proceeding with commits
+- Run specific test suites for targeted changes when appropriate
+
+## Test Development Standards
+
+- **New Features:** Ensure all new features have corresponding unit tests
+- **Test Coverage:** Aim for high coverage of critical functionality paths
+- **Test Documentation:** Follow table format in `test/test-documentation.md` for all test cases
+- **Test Organization:** Group related tests in describe blocks with clear hierarchy
+
+## Test Case Documentation Format
+
+All test cases must be documented using the standardized table format:
+
+```markdown
+| Test Case ID  | Description                                 | Type | Status    |
+| :------------ | :------------------------------------------ | :--- | :-------- |
+| AREA-TYPE-001 | Brief but descriptive test case description | Unit | Completed |
+```
+
+## Test Case Naming Conventions
+
+### Test Case ID Format: `[AREA]-[TYPE]-[NUMBER]`
+
+**Area Prefixes (Python/Django specific):**
+
+- `VIEW` - Django views/FastAPI endpoints tests
+- `MODEL` - Django models/SQLAlchemy tests
+- `FORM` - Django forms/Pydantic validators tests
+- `MW` - Middleware tests
+- `AUTH` - Authentication/Authorization tests
+- `UTIL` - Utility function tests
+- `CMD` - Django management commands tests
+- `CONFIG` - Configuration/Settings tests
+- `DOC` - Documentation Quality tests
+- `E2E` - End-to-End workflow tests
+- `INT` - Integration tests
+
+**Type Suffixes:**
+
+- `UNIT` - Unit tests
+- `INT` - Integration tests
+- `E2E` - End-to-end tests
+
+**Examples:**
+
+- `VIEW-UNIT-001` - First unit test for Django Views
+- `MODEL-UNIT-001` - First unit test for Django Models
+- `AUTH-INT-001` - First integration test for Authentication
+- `E2E-WF-001` - First end-to-end workflow test
+
+### Test Method Naming
+
+- Format: `methodName_scenario_expectedOutcome`
+- Example: `getUserById_userExists_returnsUserObject`
+- Use camelCase for all test method names
+
+## Test Data Management
+
+- **Fixtures:** Update test fixtures when data structures change
+- **Realistic Data:** Use realistic data in integration tests to catch real-world issues
+- **Mock Strategy:** Mock external dependencies in unit tests for isolation
+- **Test Database:** Use separate test database/environment for integration tests
+- **Temporary File Cleanup:** Clean up all temporary test files, debug outputs, and mock data after test execution
+- **Fixture Organization:** Move reusable test data to `/test/fixtures/` directory for proper organization
+
+## Test File Hygiene
+
+- **No Orphaned Files:** Remove temporary test files created during debugging or development
+- **Debug Output Cleanup:** Remove console.log statements and debug files before committing
+- **Test Artifact Management:** Ensure test screenshots, logs, and reports are properly managed or cleaned up
+- **Resource Management:** Properly dispose of file handles, database connections, and other test resources
+
+## Test Types and Patterns
+
+- **Unit Tests:** Test individual functions, methods, and components in isolation
+- **Integration Tests:** Test feature workflows and component interactions
+- **End-to-End Tests:** Test complete user scenarios and workflows
+- **Regression Tests:** Add tests for previously fixed bugs to prevent recurrence
+
+## Performance Testing
+
+- **Test Execution Speed:** Keep unit tests fast (under 100ms each when possible)
+- **Parallel Execution:** Structure tests to run safely in parallel
+- **Resource Cleanup:** Ensure proper cleanup of test resources and temporary data
+- **Memory Management:** Monitor and prevent memory leaks in long-running test suites
+
+## Test Maintenance
+
+- **Regular Review:** Periodically review and refactor outdated tests
+- **Documentation:** Document complex test scenarios and their purposes
+- **Continuous Updates:** Update tests when requirements or APIs change
+- **Test Quality:** Apply the same code quality standards to test code as production code
+- **Update test-documentation.md:** Add new test cases to the appropriate table section
+- **Status Tracking:** Update test status as development progresses
+- **Table Format:** Maintain consistent table formatting and column alignment
+- **ID Assignment:** Assign sequential IDs within each area (AREA-TYPE-001, AREA-TYPE-002, etc.)

package/templates/python/template.json

@@ -0,0 +1,75 @@
+{
+  "name": "python",
+  "description": "Python backend development template with Django, Flask, and FastAPI support",
+  "projectTypes": [
+    "Python Application",
+    "Django Application",
+    "Flask Application",
+    "FastAPI Application"
+  ],
+  "techStack": ["Python", "Django", "Flask", "FastAPI", "SQLAlchemy", "pytest"],
+  "vscodeSettings": {
+    "github.copilot.chat.codeGeneration.useInstructionFiles": true,
+    "chat.promptFiles": true,
+    "python.defaultInterpreterPath": "./venv/bin/python",
+    "python.terminal.activateEnvironment": true,
+    "python.testing.pytestEnabled": true,
+    "python.testing.unittestEnabled": false,
+    "python.testing.pytestArgs": ["."],
+    "python.linting.enabled": true,
+    "python.linting.pylintEnabled": false,
+    "python.linting.flake8Enabled": true,
+    "python.formatting.provider": "black",
+    "python.sortImports.args": ["--profile", "black"]
+  },
+  "gitignore": [
+    "__pycache__/",
+    "*.py[cod]",
+    "*$py.class",
+    "*.so",
+    ".Python",
+    "build/",
+    "develop-eggs/",
+    "dist/",
+    "downloads/",
+    "eggs/",
+    ".eggs/",
+    "lib/",
+    "lib64/",
+    "parts/",
+    "sdist/",
+    "var/",
+    "wheels/",
+    "*.egg-info/",
+    ".installed.cfg",
+    "*.egg",
+    "MANIFEST",
+    "*.manifest",
+    "*.spec",
+    "pip-log.txt",
+    "pip-delete-this-directory.txt",
+    ".tox/",
+    ".coverage",
+    ".pytest_cache/",
+    ".coverage.*",
+    "coverage.xml",
+    "*.cover",
+    ".hypothesis/",
+    ".env",
+    ".venv",
+    "env/",
+    "venv/",
+    "ENV/",
+    "env.bak/",
+    "venv.bak/",
+    ".mypy_cache/",
+    ".dmypy.json",
+    "dmypy.json",
+    "db.sqlite3",
+    "*.log",
+    "celerybeat-schedule",
+    "celerybeat.pid",
+    "staticfiles/",
+    "media/"
+  ]
+}

package/templates/react/files/code-review.instructions.md

@@ -0,0 +1,160 @@
+---
+description: 'Automated code review checklist'
+applyTo: '**'
+---
+
+# Code Review Focus Areas
+
+## React-Specific Functionality Assessment
+
+- **Component Props:** Are prop interfaces well-defined and type-safe?
+- **State Management:** Is state handled appropriately (local vs global)?
+- **Effect Dependencies:** Are useEffect dependencies complete and accurate?
+- **Event Handlers:** Are event handlers properly memoized when needed?
+- **Conditional Rendering:** Are all rendering paths tested and accessible?
+
+## React Component Quality
+
+- **Single Responsibility:** Does each component have a single, clear purpose?
+- **Component Size:** Are components reasonably sized and focused?
+- **Props Design:** Are props minimal, well-typed, and follow interface patterns?
+- **Hook Usage:** Are hooks used correctly and following Rules of Hooks?
+- **JSX Quality:** Is JSX readable, semantic, and properly structured?
+
+## React Performance Considerations
+
+- **Re-render Optimization:** Are unnecessary re-renders prevented with memo/callback?
+- **Bundle Size:** Do imports follow tree-shaking best practices?
+- **Lazy Loading:** Are code splitting opportunities identified and implemented?
+- **Memory Leaks:** Are effects cleaned up properly on unmount?
+- **Key Props:** Are list items using stable, unique keys?
+
+## React Security and Accessibility
+
+- **XSS Prevention:** Is user input properly sanitized in JSX?
+- **ARIA Compliance:** Are interactive elements properly labeled?
+- **Semantic HTML:** Are semantic HTML elements used instead of generic divs?
+- **Keyboard Navigation:** Are all interactive elements keyboard accessible?
+- **Focus Management:** Is focus handled correctly for dynamic content?
+
+## React Testing Quality
+
+- **Component Testing:** Are components tested using React Testing Library?
+- **User-Focused Tests:** Do tests verify user behavior rather than implementation?
+- **Hook Testing:** Are custom hooks tested independently?
+- **Integration Testing:** Are component interactions tested realistically?
+- **Accessibility Testing:** Are accessibility features included in tests?
+
+## React File and Component Hygiene
+
+- **Component Cleanup:** Are temporary/experimental React components removed from the codebase?
+- **JSX Debug Elements:** Are debug divs, temporary styling, and console.log statements removed?
+- **Unused Imports:** Are unused React imports, hooks, and component imports cleaned up?
+- **Mock Component Removal:** Are temporary mock components moved to proper mock directories or removed?
+- **Storybook Integration:** Are useful component experiments moved to Storybook stories?
+- **Style Experiments:** Are temporary CSS/styled-component experiments cleaned up or properly organized?
+
+## React-Specific Anti-Patterns to Flag
+
+- **Direct State Mutation:** Mutating state objects directly instead of using setState
+- **Missing Keys:** Using array indices or missing keys in lists
+- **Inline Object Creation:** Creating objects/functions in render without memoization
+- **useEffect Overuse:** Using useEffect when derived state would suffice
+- **Props Drilling:** Passing props through multiple levels unnecessarily
+- **God Components:** Components handling too many concerns
+
+## Functionality Assessment
+
+- **Requirements Compliance:** Does the code meet the specified requirements?
+- **Edge Cases:** Are edge cases properly handled?
+- **Error Scenarios:** How does the code behave with invalid inputs?
+- **Business Logic:** Is the business logic correctly implemented?
+- **Integration Points:** Do integrations with other components work correctly?
+
+## Code Quality and Readability
+
+- **Naming Conventions:** Are variables, functions, and classes named clearly?
+- **Code Structure:** Is the code well-organized and logically structured?
+- **Function Size:** Are functions focused and reasonably sized (< 50 lines)?
+- **Complexity:** Is the code unnecessarily complex or could it be simplified?
+- **Comments:** Are comments helpful and explain "why" not "what"?
+- **Consistency:** Does the code follow established project patterns?
+
+## Performance Considerations
+
+- **Algorithm Efficiency:** Are appropriate algorithms and data structures used?
+- **Memory Usage:** Are there potential memory leaks or excessive memory usage?
+- **Database Queries:** Are database queries optimized and avoid N+1 problems?
+- **Async Operations:** Are async operations used appropriately for I/O?
+- **Caching:** Are caching opportunities identified and implemented correctly?
+- **Resource Management:** Are resources properly acquired and released?
+
+## Security Review
+
+- **Input Validation:** Are all inputs properly validated and sanitized?
+- **Authentication:** Are authentication checks in place where needed?
+- **Authorization:** Are authorization checks appropriate for the functionality?
+- **Data Exposure:** Is sensitive data properly protected?
+- **Injection Attacks:** Are SQL injection and other injection attacks prevented?
+- **Encryption:** Is sensitive data encrypted appropriately?
+
+## Testing and Testability
+
+- **Test Coverage:** Are there sufficient tests for the new functionality?
+- **Test Quality:** Are tests meaningful and test the right things?
+- **Testability:** Is the code structured to be easily testable?
+- **Mocking:** Are external dependencies properly mocked in tests?
+- **Integration Tests:** Are integration points covered by appropriate tests?
+- **Regression Protection:** Do tests protect against known regression issues?
+
+## Error Handling and Logging
+
+- **Exception Handling:** Are exceptions handled appropriately?
+- **Error Messages:** Are error messages helpful for debugging?
+- **Logging:** Is appropriate logging in place for debugging and monitoring?
+- **Graceful Degradation:** Does the system handle failures gracefully?
+- **Recovery:** Are there appropriate recovery mechanisms?
+
+## Documentation and Maintenance
+
+- **Code Documentation:** Is the code self-documenting or properly commented?
+- **API Documentation:** Are public APIs documented with JSDoc?
+- **Breaking Changes:** Are breaking changes clearly identified and documented?
+- **Migration Guides:** Are migration paths provided for breaking changes?
+- **Changelog Updates:** Are user-facing changes documented in changelog?
+
+## Standards Compliance
+
+- **Coding Standards:** Does the code follow project coding standards?
+- **Architectural Patterns:** Are established architectural patterns followed?
+- **Dependency Management:** Are new dependencies justified and properly managed?
+- **Configuration:** Are configuration changes handled appropriately?
+- **Version Compatibility:** Is backwards compatibility maintained where required?
+
+## Common Anti-Patterns to Flag
+
+- **Deep Nesting:** Excessive if/else or try/catch nesting
+- **God Objects:** Classes or functions with too many responsibilities
+- **Magic Numbers:** Hardcoded values without explanation
+- **Copy-Paste Code:** Duplicated code that should be refactored
+- **Tight Coupling:** Components that are too dependent on each other
+- **Memory Leaks:** Objects not properly cleaned up
+- **Blocking Operations:** Synchronous operations that could block the main thread
+
+## Review Process Guidelines
+
+- **Constructive Feedback:** Provide specific, actionable feedback
+- **Explain Reasoning:** Explain why changes are needed
+- **Suggest Alternatives:** Offer alternative approaches when applicable
+- **Acknowledge Good Work:** Recognize well-written code and good practices
+- **Focus on Code:** Keep feedback focused on code, not personal
+- **Prioritize Issues:** Distinguish between critical issues and suggestions
+
+## Automated Checks to Verify
+
+- **Linting:** Code passes linting rules
+- **Formatting:** Code follows formatting standards
+- **Type Checking:** TypeScript compilation succeeds without errors
+- **Tests:** All tests pass including new and existing ones
+- **Build:** Code builds successfully
+- **Security Scans:** Automated security scans pass