@ngxtm/devkit 3.7.0 → 3.9.0

package/merged-commands/code-review-checklist.md

@@ -0,0 +1,444 @@
+---
+name: code-review-checklist
+description: "Comprehensive checklist for conducting thorough code reviews covering functionality, security, performance, and maintainability"
+---
+
+# Code Review Checklist
+
+## Overview
+
+Provide a systematic checklist for conducting thorough code reviews. This skill helps reviewers ensure code quality, catch bugs, identify security issues, and maintain consistency across the codebase.
+
+## When to Use This Skill
+
+- Use when reviewing pull requests
+- Use when conducting code audits
+- Use when establishing code review standards for a team
+- Use when training new developers on code review practices
+- Use when you want to ensure nothing is missed in reviews
+- Use when creating code review documentation
+
+## How It Works
+
+### Step 1: Understand the Context
+
+Before reviewing code, I'll help you understand:
+- What problem does this code solve?
+- What are the requirements?
+- What files were changed and why?
+- Are there related issues or tickets?
+- What's the testing strategy?
+
+### Step 2: Review Functionality
+
+Check if the code works correctly:
+- Does it solve the stated problem?
+- Are edge cases handled?
+- Is error handling appropriate?
+- Are there any logical errors?
+- Does it match the requirements?
+
+### Step 3: Review Code Quality
+
+Assess code maintainability:
+- Is the code readable and clear?
+- Are names descriptive?
+- Is it properly structured?
+- Are functions/methods focused?
+- Is there unnecessary complexity?
+
+### Step 4: Review Security
+
+Check for security issues:
+- Are inputs validated?
+- Is sensitive data protected?
+- Are there SQL injection risks?
+- Is authentication/authorization correct?
+- Are dependencies secure?
+
+### Step 5: Review Performance
+
+Look for performance issues:
+- Are there unnecessary loops?
+- Is database access optimized?
+- Are there memory leaks?
+- Is caching used appropriately?
+- Are there N+1 query problems?
+
+### Step 6: Review Tests
+
+Verify test coverage:
+- Are there tests for new code?
+- Do tests cover edge cases?
+- Are tests meaningful?
+- Do all tests pass?
+- Is test coverage adequate?
+
+## Examples
+
+### Example 1: Functionality Review Checklist
+
+```markdown
+## Functionality Review
+
+### Requirements
+- [ ] Code solves the stated problem
+- [ ] All acceptance criteria are met
+- [ ] Edge cases are handled
+- [ ] Error cases are handled
+- [ ] User input is validated
+
+### Logic
+- [ ] No logical errors or bugs
+- [ ] Conditions are correct (no off-by-one errors)
+- [ ] Loops terminate correctly
+- [ ] Recursion has proper base cases
+- [ ] State management is correct
+
+### Error Handling
+- [ ] Errors are caught appropriately
+- [ ] Error messages are clear and helpful
+- [ ] Errors don't expose sensitive information
+- [ ] Failed operations are rolled back
+- [ ] Logging is appropriate
+
+### Example Issues to Catch:
+
+**❌ Bad - Missing validation:**
+\`\`\`javascript
+function createUser(email, password) {
+  // No validation!
+  return db.users.create({ email, password });
+}
+\`\`\`
+
+**✅ Good - Proper validation:**
+\`\`\`javascript
+function createUser(email, password) {
+  if (!email || !isValidEmail(email)) {
+    throw new Error('Invalid email address');
+  }
+  if (!password || password.length < 8) {
+    throw new Error('Password must be at least 8 characters');
+  }
+  return db.users.create({ email, password });
+}
+\`\`\`
+```
+
+### Example 2: Security Review Checklist
+
+```markdown
+## Security Review
+
+### Input Validation
+- [ ] All user inputs are validated
+- [ ] SQL injection is prevented (use parameterized queries)
+- [ ] XSS is prevented (escape output)
+- [ ] CSRF protection is in place
+- [ ] File uploads are validated (type, size, content)
+
+### Authentication & Authorization
+- [ ] Authentication is required where needed
+- [ ] Authorization checks are present
+- [ ] Passwords are hashed (never stored plain text)
+- [ ] Sessions are managed securely
+- [ ] Tokens expire appropriately
+
+### Data Protection
+- [ ] Sensitive data is encrypted
+- [ ] API keys are not hardcoded
+- [ ] Environment variables are used for secrets
+- [ ] Personal data follows privacy regulations
+- [ ] Database credentials are secure
+
+### Dependencies
+- [ ] No known vulnerable dependencies
+- [ ] Dependencies are up to date
+- [ ] Unnecessary dependencies are removed
+- [ ] Dependency versions are pinned
+
+### Example Issues to Catch:
+
+**❌ Bad - SQL injection risk:**
+\`\`\`javascript
+const query = \`SELECT * FROM users WHERE email = '\${email}'\`;
+db.query(query);
+\`\`\`
+
+**✅ Good - Parameterized query:**
+\`\`\`javascript
+const query = 'SELECT * FROM users WHERE email = $1';
+db.query(query, [email]);
+\`\`\`
+
+**❌ Bad - Hardcoded secret:**
+\`\`\`javascript
+const API_KEY = 'sk_live_abc123xyz';
+\`\`\`
+
+**✅ Good - Environment variable:**
+\`\`\`javascript
+const API_KEY = process.env.API_KEY;
+if (!API_KEY) {
+  throw new Error('API_KEY environment variable is required');
+}
+\`\`\`
+```
+
+### Example 3: Code Quality Review Checklist
+
+```markdown
+## Code Quality Review
+
+### Readability
+- [ ] Code is easy to understand
+- [ ] Variable names are descriptive
+- [ ] Function names explain what they do
+- [ ] Complex logic has comments
+- [ ] Magic numbers are replaced with constants
+
+### Structure
+- [ ] Functions are small and focused
+- [ ] Code follows DRY principle (Don't Repeat Yourself)
+- [ ] Proper separation of concerns
+- [ ] Consistent code style
+- [ ] No dead code or commented-out code
+
+### Maintainability
+- [ ] Code is modular and reusable
+- [ ] Dependencies are minimal
+- [ ] Changes are backwards compatible
+- [ ] Breaking changes are documented
+- [ ] Technical debt is noted
+
+### Example Issues to Catch:
+
+**❌ Bad - Unclear naming:**
+\`\`\`javascript
+function calc(a, b, c) {
+  return a * b + c;
+}
+\`\`\`
+
+**✅ Good - Descriptive naming:**
+\`\`\`javascript
+function calculateTotalPrice(quantity, unitPrice, tax) {
+  return quantity * unitPrice + tax;
+}
+\`\`\`
+
+**❌ Bad - Function doing too much:**
+\`\`\`javascript
+function processOrder(order) {
+  // Validate order
+  if (!order.items) throw new Error('No items');
+  
+  // Calculate total
+  let total = 0;
+  for (let item of order.items) {
+    total += item.price * item.quantity;
+  }
+  
+  // Apply discount
+  if (order.coupon) {
+    total *= 0.9;
+  }
+  
+  // Process payment
+  const payment = stripe.charge(total);
+  
+  // Send email
+  sendEmail(order.email, 'Order confirmed');
+  
+  // Update inventory
+  updateInventory(order.items);
+  
+  return { orderId: order.id, total };
+}
+\`\`\`
+
+**✅ Good - Separated concerns:**
+\`\`\`javascript
+function processOrder(order) {
+  validateOrder(order);
+  const total = calculateOrderTotal(order);
+  const payment = processPayment(total);
+  sendOrderConfirmation(order.email);
+  updateInventory(order.items);
+  
+  return { orderId: order.id, total };
+}
+\`\`\`
+```
+
+## Best Practices
+
+### ✅ Do This
+
+- **Review Small Changes** - Smaller PRs are easier to review thoroughly
+- **Check Tests First** - Verify tests pass and cover new code
+- **Run the Code** - Test it locally when possible
+- **Ask Questions** - Don't assume, ask for clarification
+- **Be Constructive** - Suggest improvements, don't just criticize
+- **Focus on Important Issues** - Don't nitpick minor style issues
+- **Use Automated Tools** - Linters, formatters, security scanners
+- **Review Documentation** - Check if docs are updated
+- **Consider Performance** - Think about scale and efficiency
+- **Check for Regressions** - Ensure existing functionality still works
+
+### ❌ Don't Do This
+
+- **Don't Approve Without Reading** - Actually review the code
+- **Don't Be Vague** - Provide specific feedback with examples
+- **Don't Ignore Security** - Security issues are critical
+- **Don't Skip Tests** - Untested code will cause problems
+- **Don't Be Rude** - Be respectful and professional
+- **Don't Rubber Stamp** - Every review should add value
+- **Don't Review When Tired** - You'll miss important issues
+- **Don't Forget Context** - Understand the bigger picture
+
+## Complete Review Checklist
+
+### Pre-Review
+- [ ] Read the PR description and linked issues
+- [ ] Understand what problem is being solved
+- [ ] Check if tests pass in CI/CD
+- [ ] Pull the branch and run it locally
+
+### Functionality
+- [ ] Code solves the stated problem
+- [ ] Edge cases are handled
+- [ ] Error handling is appropriate
+- [ ] User input is validated
+- [ ] No logical errors
+
+### Security
+- [ ] No SQL injection vulnerabilities
+- [ ] No XSS vulnerabilities
+- [ ] Authentication/authorization is correct
+- [ ] Sensitive data is protected
+- [ ] No hardcoded secrets
+
+### Performance
+- [ ] No unnecessary database queries
+- [ ] No N+1 query problems
+- [ ] Efficient algorithms used
+- [ ] No memory leaks
+- [ ] Caching used appropriately
+
+### Code Quality
+- [ ] Code is readable and clear
+- [ ] Names are descriptive
+- [ ] Functions are focused and small
+- [ ] No code duplication
+- [ ] Follows project conventions
+
+### Tests
+- [ ] New code has tests
+- [ ] Tests cover edge cases
+- [ ] Tests are meaningful
+- [ ] All tests pass
+- [ ] Test coverage is adequate
+
+### Documentation
+- [ ] Code comments explain why, not what
+- [ ] API documentation is updated
+- [ ] README is updated if needed
+- [ ] Breaking changes are documented
+- [ ] Migration guide provided if needed
+
+### Git
+- [ ] Commit messages are clear
+- [ ] No merge conflicts
+- [ ] Branch is up to date with main
+- [ ] No unnecessary files committed
+- [ ] .gitignore is properly configured
+
+## Common Pitfalls
+
+### Problem: Missing Edge Cases
+**Symptoms:** Code works for happy path but fails on edge cases
+**Solution:** Ask "What if...?" questions
+- What if the input is null?
+- What if the array is empty?
+- What if the user is not authenticated?
+- What if the network request fails?
+
+### Problem: Security Vulnerabilities
+**Symptoms:** Code exposes security risks
+**Solution:** Use security checklist
+- Run security scanners (npm audit, Snyk)
+- Check OWASP Top 10
+- Validate all inputs
+- Use parameterized queries
+- Never trust user input
+
+### Problem: Poor Test Coverage
+**Symptoms:** New code has no tests or inadequate tests
+**Solution:** Require tests for all new code
+- Unit tests for functions
+- Integration tests for features
+- Edge case tests
+- Error case tests
+
+### Problem: Unclear Code
+**Symptoms:** Reviewer can't understand what code does
+**Solution:** Request improvements
+- Better variable names
+- Explanatory comments
+- Smaller functions
+- Clear structure
+
+## Review Comment Templates
+
+### Requesting Changes
+```markdown
+**Issue:** [Describe the problem]
+
+**Current code:**
+\`\`\`javascript
+// Show problematic code
+\`\`\`
+
+**Suggested fix:**
+\`\`\`javascript
+// Show improved code
+\`\`\`
+
+**Why:** [Explain why this is better]
+```
+
+### Asking Questions
+```markdown
+**Question:** [Your question]
+
+**Context:** [Why you're asking]
+
+**Suggestion:** [If you have one]
+```
+
+### Praising Good Code
+```markdown
+**Nice!** [What you liked]
+
+This is great because [explain why]
+```
+
+## Related Skills
+
+- `@requesting-code-review` - Prepare code for review
+- `@receiving-code-review` - Handle review feedback
+- `@systematic-debugging` - Debug issues found in review
+- `@test-driven-development` - Ensure code has tests
+
+## Additional Resources
+
+- [Google Code Review Guidelines](https://google.github.io/eng-practices/review/)
+- [OWASP Top 10](https://owasp.org/www-project-top-ten/)
+- [Code Review Best Practices](https://github.com/thoughtbot/guides/tree/main/code-review)
+- [How to Review Code](https://www.kevinlondon.com/2015/05/05/code-review-best-practices.html)
+
+---
+
+**Pro Tip:** Use a checklist template for every review to ensure consistency and thoroughness. Customize it for your team's specific needs!

package/merged-commands/code-review-excellence.md

@@ -0,0 +1,40 @@
+---
+name: code-review-excellence
+description: Master effective code review practices to provide constructive feedback, catch bugs early, and foster knowledge sharing while maintaining team morale. Use when reviewing pull requests, establishing review standards, or mentoring developers.
+---
+
+# Code Review Excellence
+
+Transform code reviews from gatekeeping to knowledge sharing through constructive feedback, systematic analysis, and collaborative improvement.
+
+## Use this skill when
+
+- Reviewing pull requests and code changes
+- Establishing code review standards
+- Mentoring developers through review feedback
+- Auditing for correctness, security, or performance
+
+## Do not use this skill when
+
+- There are no code changes to review
+- The task is a design-only discussion without code
+- You need to implement fixes instead of reviewing
+
+## Instructions
+
+- Read context, requirements, and test signals first.
+- Review for correctness, security, performance, and maintainability.
+- Provide actionable feedback with severity and rationale.
+- Ask clarifying questions when intent is unclear.
+- If detailed checklists are required, open `resources/implementation-playbook.md`.
+
+## Output Format
+
+- High-level summary of findings
+- Issues grouped by severity (blocking, important, minor)
+- Suggestions and questions
+- Test and coverage notes
+
+## Resources
+
+- `resources/implementation-playbook.md` for detailed review patterns and templates.

package/merged-commands/code-review.md

@@ -0,0 +1,121 @@
+---
+name: code-review
+description: Automated code review for pull requests using specialized review patterns. Analyzes code for quality, security, performance, and best practices. Use when reviewing code changes, PRs, or doing code audits.
+source: anthropics/claude-code
+license: Apache-2.0
+---
+
+# Code Review
+
+## Review Categories
+
+### 1. Security Review
+Check for:
+- SQL injection vulnerabilities
+- XSS (Cross-Site Scripting)
+- Command injection
+- Insecure deserialization
+- Hardcoded secrets/credentials
+- Improper authentication/authorization
+- Insecure direct object references
+
+### 2. Performance Review
+Check for:
+- N+1 queries
+- Missing database indexes
+- Unnecessary re-renders (React)
+- Memory leaks
+- Blocking operations in async code
+- Missing caching opportunities
+- Large bundle sizes
+
+### 3. Code Quality Review
+Check for:
+- Code duplication (DRY violations)
+- Functions doing too much (SRP violations)
+- Deep nesting / complex conditionals
+- Magic numbers/strings
+- Poor naming
+- Missing error handling
+- Incomplete type coverage
+
+### 4. Testing Review
+Check for:
+- Missing test coverage for new code
+- Tests that don't test behavior
+- Flaky test patterns
+- Missing edge cases
+- Mocked external dependencies
+
+## Review Output Format
+
+```markdown
+## Code Review Summary
+
+### 🔴 Critical (Must Fix)
+- **[File:Line]** [Issue description]
+  - **Why:** [Explanation]
+  - **Fix:** [Suggested fix]
+
+### 🟡 Suggestions (Should Consider)
+- **[File:Line]** [Issue description]
+  - **Why:** [Explanation]
+  - **Fix:** [Suggested fix]
+
+### 🟢 Nits (Optional)
+- **[File:Line]** [Minor suggestion]
+
+### ✅ What's Good
+- [Positive feedback on good patterns]
+```
+
+## Common Patterns to Flag
+
+### Security
+```javascript
+// BAD: SQL injection
+const query = `SELECT * FROM users WHERE id = ${userId}`;
+
+// GOOD: Parameterized query
+const query = 'SELECT * FROM users WHERE id = $1';
+await db.query(query, [userId]);
+```
+
+### Performance
+```javascript
+// BAD: N+1 query
+users.forEach(async user => {
+  const posts = await getPosts(user.id);
+});
+
+// GOOD: Batch query
+const userIds = users.map(u => u.id);
+const posts = await getPostsForUsers(userIds);
+```
+
+### Error Handling
+```javascript
+// BAD: Swallowing errors
+try {
+  await riskyOperation();
+} catch (e) {}
+
+// GOOD: Handle or propagate
+try {
+  await riskyOperation();
+} catch (e) {
+  logger.error('Operation failed', { error: e });
+  throw new AppError('Operation failed', { cause: e });
+}
+```
+
+## Review Checklist
+
+- [ ] No hardcoded secrets
+- [ ] Input validation present
+- [ ] Error handling complete
+- [ ] Types/interfaces defined
+- [ ] Tests added for new code
+- [ ] No obvious performance issues
+- [ ] Code is readable and documented
+- [ ] Breaking changes documented