zhongwei/gh-linus-mcmanamey-unify-2-1-plugin
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Zhongwei Li
2025-11-30 08:37:55 +08:00
commit 506a828b22
59 changed files with 18515 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

116
commands/refactor-code.md Executable file
View File

@@ -0,0 +1,116 @@
# Intelligently Refactor and Improve Code Quality
Intelligently refactor and improve code quality
## Instructions
Follow this systematic approach to refactor code: **$ARGUMENTS**
1. **Pre-Refactoring Analysis**
- Identify the code that needs refactoring and the reasons why
- Understand the current functionality and behavior completely
- Review existing tests and documentation
- Identify all dependencies and usage points
2. **Test Coverage Verification**
- Ensure comprehensive test coverage exists for the code being refactored
- If tests are missing, write them BEFORE starting refactoring
- Run all tests to establish a baseline
- Document current behavior with additional tests if needed
3. **Refactoring Strategy**
- Define clear goals for the refactoring (performance, readability, maintainability)
- Choose appropriate refactoring techniques:
- Extract Method/Function
- Extract Class/Component
- Rename Variable/Method
- Move Method/Field
- Replace Conditional with Polymorphism
- Eliminate Dead Code
- Plan the refactoring in small, incremental steps
4. **Environment Setup**
- Create a new branch: `git checkout -b refactor/$ARGUMENTS`
- Ensure all tests pass before starting
- Set up any additional tooling needed (profilers, analyzers)
5. **Incremental Refactoring**
- Make small, focused changes one at a time
- Run tests after each change to ensure nothing breaks
- Commit working changes frequently with descriptive messages
- Use IDE refactoring tools when available for safety
6. **Code Quality Improvements**
- Improve naming conventions for clarity
- Eliminate code duplication (DRY principle)
- Simplify complex conditional logic
- Reduce method/function length and complexity
- Improve separation of concerns
7. **Performance Optimizations**
- Identify and eliminate performance bottlenecks
- Optimize algorithms and data structures
- Reduce unnecessary computations
- Improve memory usage patterns
8. **Design Pattern Application**
- Apply appropriate design patterns where beneficial
- Improve abstraction and encapsulation
- Enhance modularity and reusability
- Reduce coupling between components
9. **Error Handling Improvement**
- Standardize error handling approaches
- Improve error messages and logging
- Add proper exception handling
- Enhance resilience and fault tolerance
10. **Documentation Updates**
- Update code comments to reflect changes
- Revise API documentation if interfaces changed
- Update inline documentation and examples
- Ensure comments are accurate and helpful
11. **Testing Enhancements**
- Add tests for any new code paths created
- Improve existing test quality and coverage
- Remove or update obsolete tests
- Ensure tests are still meaningful and effective
12. **Static Analysis**
- Run linting tools to catch style and potential issues
- Use static analysis tools to identify problems
- Check for security vulnerabilities
- Verify code complexity metrics
13. **Performance Verification**
- Run performance benchmarks if applicable
- Compare before/after metrics
- Ensure refactoring didn't degrade performance
- Document any performance improvements
14. **Integration Testing**
- Run full test suite to ensure no regressions
- Test integration with dependent systems
- Verify all functionality works as expected
- Test edge cases and error scenarios
15. **Code Review Preparation**
- Review all changes for quality and consistency
- Ensure refactoring goals were achieved
- Prepare clear explanation of changes made
- Document benefits and rationale
16. **Documentation of Changes**
- Create a summary of refactoring changes
- Document any breaking changes or new patterns
- Update project documentation if needed
- Explain benefits and reasoning for future reference
17. **Deployment Considerations**
- Plan deployment strategy for refactored code
- Consider feature flags for gradual rollout
- Prepare rollback procedures
- Set up monitoring for the refactored components
Remember: Refactoring should preserve external behavior while improving internal structure. Always prioritize safety over speed, and maintain comprehensive test coverage throughout the process.