claude-all-config 2.0.0

package/skills/integration-testing/examples/e2e-test.js

@@ -0,0 +1,147 @@
+// End-to-End Test Example
+// Tests the complete user journey from registration to purchase
+
+const { test, expect } = require('@playwright/test');
+
+test.describe('E2E User Journey', () => {
+  test.beforeEach(async ({ page }) => {
+    // Set up test data
+    await setupTestData();
+  });
+
+  test('user can register, login, and make a purchase', async ({ page }) => {
+    // 1. Registration
+    await page.goto('/register');
+
+    await page.fill('[data-testid="email"]', 'test@example.com');
+    await page.fill('[data-testid="password"]', 'SecurePass123!');
+    await page.fill('[data-testid="confirmPassword"]', 'SecurePass123!');
+
+    await page.click('[data-testid="register-button"]');
+
+    // Verify successful registration
+    await expect(page.locator('[data-testid="success-message"]'))
+      .toContainText('Registration successful');
+
+    // 2. Login
+    await page.goto('/login');
+
+    await page.fill('[data-testid="email"]', 'test@example.com');
+    await page.fill('[data-testid="password"]', 'SecurePass123!');
+
+    await page.click('[data-testid="login-button"]');
+
+    // Verify logged in
+    await expect(page.locator('[data-testid="user-menu"]')).toBeVisible();
+
+    // 3. Browse products
+    await page.goto('/products');
+    await page.click('[data-testid="product-card"]:first-child');
+
+    // 4. Add to cart
+    await page.click('[data-testid="add-to-cart"]');
+    await expect(page.locator('[data-testid="cart-count"]'))
+      .toContainText('1');
+
+    // 5. Checkout
+    await page.click('[data-testid="cart-icon"]');
+    await page.click('[data-testid="checkout-button"]');
+
+    // Fill shipping info
+    await page.fill('[data-testid="shipping-address"]', '123 Test St');
+    await page.fill('[data-testid="shipping-city"]', 'Test City');
+    await page.fill('[data-testid="shipping-zip"]', '12345');
+
+    // Add payment info
+    await page.fill('[data-testid="card-number"]', '4242424242424242');
+    await page.fill('[data-testid="card-expiry"]', '12/25');
+    await page.fill('[data-testid="card-cvc"]', '123');
+
+    await page.click('[data-testid="place-order"]');
+
+    // Verify order confirmation
+    await expect(page.locator('[data-testid="order-confirmation"]'))
+      .toContainText('Order placed successfully');
+    await expect(page.locator('[data-testid="order-number"]'))
+      .toMatch(/ORD-\d+/);
+
+    // 6. Verify order in user dashboard
+    await page.goto('/dashboard/orders');
+    await expect(page.locator('[data-testid="order-item"]'))
+      .toContainText('ORD-');
+  });
+
+  test('handles errors gracefully', async ({ page }) => {
+    // Test network error handling
+    await page.route('/api/products', route => route.abort());
+
+    await page.goto('/products');
+    await expect(page.locator('[data-testid="error-message"]'))
+      .toContainText('Failed to load products');
+
+    // Test retry mechanism
+    await page.unroute('/api/products');
+    await page.click('[data-testid="retry-button"]');
+
+    await expect(page.locator('[data-testid="product-list"]'))
+      .toBeVisible();
+  });
+
+  test('maintains session across pages', async ({ page }) => {
+    // Login
+    await loginAsTestUser(page);
+
+    // Navigate through different pages
+    await page.goto('/products');
+    await expect(page.locator('[data-testid="user-menu"]')).toBeVisible();
+
+    await page.goto('/profile');
+    await expect(page.locator('[data-testid="user-menu"]')).toBeVisible();
+
+    await page.goto('/support');
+    await expect(page.locator('[data-testid="user-menu"]')).toBeVisible();
+
+    // Verify session persistence after refresh
+    await page.reload();
+    await expect(page.locator('[data-testid="user-menu"]')).toBeVisible();
+  });
+
+  test('real-time updates work correctly', async ({ page }) => {
+    // Open two pages to test real-time features
+    const context = page.context();
+    const page2 = await context.newPage();
+
+    // Login as user
+    await loginAsTestUser(page);
+    await loginAsTestUser(page2);
+
+    // Start chat on first page
+    await page.goto('/chat');
+    await page.fill('[data-testid="message-input"]', 'Hello, world!');
+    await page.click('[data-testid="send-button"]');
+
+    // Verify message appears on second page
+    await page2.goto('/chat');
+    await expect(page2.locator('[data-testid="message-list"]'))
+      .toContainText('Hello, world!');
+
+    // Test typing indicators
+    await page2.fill('[data-testid="message-input"]', 'Typing...');
+    await expect(page.locator('[data-testid="typing-indicator"]'))
+      .toContainText('User is typing...');
+  });
+});
+
+// Helper functions
+async function setupTestData() {
+  // Initialize test database with required data
+  // This could involve API calls or direct database operations
+}
+
+async function loginAsTestUser(page) {
+  await page.goto('/login');
+  await page.fill('[data-testid="email"]', 'test@example.com');
+  await page.fill('[data-testid="password"]', 'SecurePass123!');
+  await page.click('[data-testid="login-button"]');
+  await expect(page.locator('[data-testid="user-menu"]')).toBeVisible();
+}

package/skills/integration-testing/examples/test-isolation.md

@@ -0,0 +1,94 @@
+# Test Isolation Best Practices
+
+## 1. Database Isolation
+
+### Using Test Containers
+```javascript
+// test-setup.js
+const { setup, teardown } = require('jest-dev-server');
+
+beforeAll(async () => {
+  await setup({
+    command: `docker run --name test-db -e POSTGRES_PASSWORD=test -p 5433:5432 -d postgres:13`,
+    port: 5433,
+    usedPortAction: 'ignore',
+  });
+});
+
+afterAll(async () => {
+  await teardown();
+  await exec('docker rm -f test-db');
+});
+```
+
+### Database Transactions
+```javascript
+// Each test runs in its own transaction
+beforeEach(async () => {
+  await db.query('BEGIN');
+});
+
+afterEach(async () => {
+  await db.query('ROLLBACK');
+});
+```
+
+## 2. Mock External Services
+
+### Service Virtualization
+```javascript
+// jest.config.js
+module.exports = {
+  setupFilesAfterEnv: ['./test/setup/mocks.js'],
+};
+
+// test/setup/mocks.js
+jest.mock('./services/payment', () => ({
+  processPayment: jest.fn().mockResolvedValue({
+    success: true,
+    transactionId: 'tx_12345',
+  }),
+}));
+```
+
+## 3. Test Data Management
+
+### Factory Pattern
+```javascript
+// factories/user-factory.js
+class UserFactory {
+  static create(overrides = {}) {
+    return {
+      id: faker.datatype.uuid(),
+      name: faker.name.findName(),
+      email: faker.internet.email(),
+      createdAt: new Date(),
+      ...overrides,
+    };
+  }
+
+  static async createInDatabase(overrides = {}) {
+    const user = this.create(overrides);
+    return await UserModel.create(user);
+  }
+}
+```
+
+## 4. Parallel Test Execution
+
+### Test Sharding
+```bash
+# Run tests in parallel
+jest --runInBand=false --shard=1/3
+jest --runInBand=false --shard=2/3
+jest --runInBand=false --shard=3/3
+```
+
+### Unique Test Data
+```javascript
+// Ensure unique data for parallel tests
+const uniqueId = `${process.env.JEST_WORKER_ID}-${Date.now()}`;
+const testData = {
+  email: `test-${uniqueId}@example.com`,
+};
+```

package/skills/logging-monitoring/SKILL.md

@@ -0,0 +1,66 @@
+
+---
+name: logging-monitoring
+description: Use when implementing logging and monitoring features - covers structured logging, log levels, performance monitoring, error tracking, log aggregation, observability, and monitoring dashboards
+---
+
+# Logging & Monitoring Skill
+
+You are a Logging & Monitoring Expert specializing in implementing robust logging and monitoring systems for production applications.
+
+## When to Use
+
+Trigger this skill when:
+- Implementing logging for new features
+- Setting up monitoring for production
+- Debugging production issues
+- Optimizing performance
+- Setting up alerting
+- Creating observability
+
+## Core Principles
+
+### Log Levels
+
+- **DEBUG**: Detailed info for development
+- **INFO**: General information (default)
+- **WARN**: Warning messages
+- **ERROR**: Error events
+- **CRITICAL**: System-fatal errors
+
+### Structured Logging
+
+Use JSON logging for machine-readability:
+
+```javascript
+logger.info('Transaction completed', {
+  transactionId: 'tx_123456',
+  userId: 'user_789',
+  timestamp: new Date().toISOString(),
+  duration_ms: 150,
+  status: 'completed'
+});
+```
+
+### Performance Metrics
+
+**Application Metrics:**
+- Request rate, response time, error rate
+- Memory usage, CPU usage
+- Active users, transaction volume
+```
+
+### Security Checklist
+
+- [ ] Security headers implemented
+- [ ] CSRF protection enabled
+- [ ] Input sanitization implemented
+- [ ] Secrets properly managed
+- [ ] Error tracking enabled
+```
+
+---
+
+**Remember**: Security is an ongoing process, not a ☂️!
+
+Check for vulnerabilities regularly!

package/skills/mobile-development/SKILL.md

@@ -0,0 +1,11 @@
+mobile-development skill helps create responsive, mobile-first applications and optimize them for native performance.
+
+For code review, check that:
+1. Mobile-first responsive design is implemented
+2. Touch interactions are properly handled
+3. Performance is optimized for mobile devices
+4. Offline functionality is considered
+5. App store guidelines are followed
+6. Battery usage is optimized
+7. Network requests are batched/optimized
+8. Gesture support is implemented where appropriate

package/skills/mobile-development/responsive/responsive.css

@@ -0,0 +1,80 @@
+/* Mobile-First Responsive Design */
+
+/* Base styles - Mobile First */
+.container {
+  width: 100%;
+  max-width: 100%;
+  padding: 0 16px;
+  margin: 0 auto;
+}
+
+/* Tablet styles */
+@media (min-width: 768px) {
+  .container {
+    max-width: 750px;
+    padding: 0 24px;
+  }
+}
+
+/* Desktop styles */
+@media (min-width: 1024px) {
+  .container {
+    max-width: 1200px;
+    padding: 0 32px;
+  }
+}
+
+/* Large desktop styles */
+@media (min-width: 1440px) {
+  .container {
+    max-width: 1440px;
+  }
+}
+
+/* Touch-friendly buttons */
+.btn {
+  min-height: 44px;
+  min-width: 44px;
+  padding: 12px 24px;
+  font-size: 16px;
+}
+
+/* Disable hover effects on mobile */
+@media (hover: none) and (pointer: coarse) {
+  .btn:hover {
+    background-color: inherit;
+  }
+}
+
+/* Optimize images for mobile */
+img {
+  max-width: 100%;
+  height: auto;
+  object-fit: cover;
+}
+
+/* Prevent horizontal scroll on mobile */
+body {
+  overflow-x: hidden;
+}
+
+/* Mobile navigation */
+.mobile-menu {
+  display: block;
+}
+
+@media (min-width: 768px) {
+  .mobile-menu {
+    display: none;
+  }
+}
+
+.desktop-menu {
+  display: none;
+}
+
+@media (min-width: 768px) {
+  .desktop-menu {
+    display: block;
+  }
+}

package/skills/performance-optimization/SKILL.md

@@ -0,0 +1,9 @@
+performance-optimization skill helps identify and resolve performance bottlenecks in applications through systematic profiling and optimization techniques.
+
+For code review, check that:
+1. Profiling has been done for critical paths
+2. Performance benchmarks exist
+3. Memory leaks are checked
+4. Algorithm complexity is optimal (O(n log n) or better)
+5. Database queries are optimized
+6. Caching strategies are implemented where appropriate

package/skills/performance-optimization/profiling/profile.template.js

@@ -0,0 +1,21 @@
+const profiler = require('v8-profiler-next');
+const fs = require('fs');
+
+// Start profiling
+profiler.startSampling();
+
+// Run your code here
+// Example: Your application logic
+for (let i = 0; i < 1000000; i++) {
+  // Code to profile
+}
+
+// Stop profiling
+profiler.stop();
+
+// Save results
+const results = profiler.buildTree();
+fs.writeFileSync('profile.json', JSON.stringify(results, null, 2));
+
+console.log('Profile saved to profile.json');
+console.log('Use Chrome DevTools > More > Tools > JavaScript Profiler to analyze');

package/skills/receiving-code-review/SKILL.md

@@ -0,0 +1,209 @@
+---
+name: receiving-code-review
+description: Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation
+---
+
+# Code Review Reception
+
+## Overview
+
+Code review requires technical evaluation, not emotional performance.
+
+**Core principle:** Verify before implementing. Ask before assuming. Technical correctness over social comfort.
+
+## The Response Pattern
+
+```
+WHEN receiving code review feedback:
+
+1. READ: Complete feedback without reacting
+2. UNDERSTAND: Restate requirement in own words (or ask)
+3. VERIFY: Check against codebase reality
+4. EVALUATE: Technically sound for THIS codebase?
+5. RESPOND: Technical acknowledgment or reasoned pushback
+6. IMPLEMENT: One item at a time, test each
+```
+
+## Forbidden Responses
+
+**NEVER:**
+- "You're absolutely right!" (explicit CLAUDE.md violation)
+- "Great point!" / "Excellent feedback!" (performative)
+- "Let me implement that now" (before verification)
+
+**INSTEAD:**
+- Restate the technical requirement
+- Ask clarifying questions
+- Push back with technical reasoning if wrong
+- Just start working (actions > words)
+
+## Handling Unclear Feedback
+
+```
+IF any item is unclear:
+  STOP - do not implement anything yet
+  ASK for clarification on unclear items
+
+WHY: Items may be related. Partial understanding = wrong implementation.
+```
+
+**Example:**
+```
+your human partner: "Fix 1-6"
+You understand 1,2,3,6. Unclear on 4,5.
+
+❌ WRONG: Implement 1,2,3,6 now, ask about 4,5 later
+✅ RIGHT: "I understand items 1,2,3,6. Need clarification on 4 and 5 before proceeding."
+```
+
+## Source-Specific Handling
+
+### From your human partner
+- **Trusted** - implement after understanding
+- **Still ask** if scope unclear
+- **No performative agreement**
+- **Skip to action** or technical acknowledgment
+
+### From External Reviewers
+```
+BEFORE implementing:
+  1. Check: Technically correct for THIS codebase?
+  2. Check: Breaks existing functionality?
+  3. Check: Reason for current implementation?
+  4. Check: Works on all platforms/versions?
+  5. Check: Does reviewer understand full context?
+
+IF suggestion seems wrong:
+  Push back with technical reasoning
+
+IF can't easily verify:
+  Say so: "I can't verify this without [X]. Should I [investigate/ask/proceed]?"
+
+IF conflicts with your human partner's prior decisions:
+  Stop and discuss with your human partner first
+```
+
+**your human partner's rule:** "External feedback - be skeptical, but check carefully"
+
+## YAGNI Check for "Professional" Features
+
+```
+IF reviewer suggests "implementing properly":
+  grep codebase for actual usage
+
+  IF unused: "This endpoint isn't called. Remove it (YAGNI)?"
+  IF used: Then implement properly
+```
+
+**your human partner's rule:** "You and reviewer both report to me. If we don't need this feature, don't add it."
+
+## Implementation Order
+
+```
+FOR multi-item feedback:
+  1. Clarify anything unclear FIRST
+  2. Then implement in this order:
+     - Blocking issues (breaks, security)
+     - Simple fixes (typos, imports)
+     - Complex fixes (refactoring, logic)
+  3. Test each fix individually
+  4. Verify no regressions
+```
+
+## When To Push Back
+
+Push back when:
+- Suggestion breaks existing functionality
+- Reviewer lacks full context
+- Violates YAGNI (unused feature)
+- Technically incorrect for this stack
+- Legacy/compatibility reasons exist
+- Conflicts with your human partner's architectural decisions
+
+**How to push back:**
+- Use technical reasoning, not defensiveness
+- Ask specific questions
+- Reference working tests/code
+- Involve your human partner if architectural
+
+**Signal if uncomfortable pushing back out loud:** "Strange things are afoot at the Circle K"
+
+## Acknowledging Correct Feedback
+
+When feedback IS correct:
+```
+✅ "Fixed. [Brief description of what changed]"
+✅ "Good catch - [specific issue]. Fixed in [location]."
+✅ [Just fix it and show in the code]
+
+❌ "You're absolutely right!"
+❌ "Great point!"
+❌ "Thanks for catching that!"
+❌ "Thanks for [anything]"
+❌ ANY gratitude expression
+```
+
+**Why no thanks:** Actions speak. Just fix it. The code itself shows you heard the feedback.
+
+**If you catch yourself about to write "Thanks":** DELETE IT. State the fix instead.
+
+## Gracefully Correcting Your Pushback
+
+If you pushed back and were wrong:
+```
+✅ "You were right - I checked [X] and it does [Y]. Implementing now."
+✅ "Verified this and you're correct. My initial understanding was wrong because [reason]. Fixing."
+
+❌ Long apology
+❌ Defending why you pushed back
+❌ Over-explaining
+```
+
+State the correction factually and move on.
+
+## Common Mistakes
+
+| Mistake | Fix |
+|---------|-----|
+| Performative agreement | State requirement or just act |
+| Blind implementation | Verify against codebase first |
+| Batch without testing | One at a time, test each |
+| Assuming reviewer is right | Check if breaks things |
+| Avoiding pushback | Technical correctness > comfort |
+| Partial implementation | Clarify all items first |
+| Can't verify, proceed anyway | State limitation, ask for direction |
+
+## Real Examples
+
+**Performative Agreement (Bad):**
+```
+Reviewer: "Remove legacy code"
+❌ "You're absolutely right! Let me remove that..."
+```
+
+**Technical Verification (Good):**
+```
+Reviewer: "Remove legacy code"
+✅ "Checking... build target is 10.15+, this API needs 13+. Need legacy for backward compat. Current impl has wrong bundle ID - fix it or drop pre-13 support?"
+```
+
+**YAGNI (Good):**
+```
+Reviewer: "Implement proper metrics tracking with database, date filters, CSV export"
+✅ "Grepped codebase - nothing calls this endpoint. Remove it (YAGNI)? Or is there usage I'm missing?"
+```
+
+**Unclear Item (Good):**
+```
+your human partner: "Fix items 1-6"
+You understand 1,2,3,6. Unclear on 4,5.
+✅ "Understand 1,2,3,6. Need clarification on 4 and 5 before implementing."
+```
+
+## The Bottom Line
+
+**External feedback = suggestions to evaluate, not orders to follow.**
+
+Verify. Question. Then implement.
+
+No performative agreement. Technical rigor always.

package/skills/refactoring/SKILL.md

@@ -0,0 +1,11 @@
+refactoring skill helps improve code quality and maintainability through systematic identification and elimination of code smells and implementation of design patterns.
+
+For code review, check that:
+1. Code has no obvious code smells (duplicate code, long methods, etc.)
+2. Design patterns are appropriately applied
+3. Code follows SOLID principles
+4. Function and class names are descriptive
+5. Comments explain "why" not "what"
+6. Code is modular and loosely coupled
+7. Test coverage is maintained
+8. Technical debt is tracked and addressed