Add comprehensive skills and documentation for various technologies

.claude/skills/testing/pytest/SKILL.md

@@ -0,0 +1,90 @@
+# pytest
+
+## Description
+
+Python testing with pytest including fixtures, parametrization, and mocking.
+
+## When to Use
+
+- Writing Python tests
+- Test fixtures and setup
+- Mocking dependencies
+
+---
+
+## Core Patterns
+
+### Basic Tests
+
+```python
+import pytest
+
+def test_addition():
+    assert 1 + 1 == 2
+
+def test_exception():
+    with pytest.raises(ValueError, match="Invalid"):
+        raise ValueError("Invalid input")
+```
+
+### Fixtures
+
+```python
+@pytest.fixture
+def user():
+    return User(id=1, name="Test")
+
+@pytest.fixture
+def db_session():
+    session = create_session()
+    yield session
+    session.close()
+
+def test_with_fixtures(user, db_session):
+    db_session.add(user)
+    assert user.id is not None
+```
+
+### Parametrization
+
+```python
+@pytest.mark.parametrize("input,expected", [
+    ("hello", "HELLO"),
+    ("world", "WORLD"),
+    ("", ""),
+])
+def test_uppercase(input, expected):
+    assert input.upper() == expected
+```
+
+### Mocking
+
+```python
+from unittest.mock import Mock, patch
+
+def test_with_mock():
+    service = Mock()
+    service.get_user.return_value = {"id": 1}
+
+    result = service.get_user(1)
+    assert result["id"] == 1
+
+@patch('module.external_api')
+def test_with_patch(mock_api):
+    mock_api.fetch.return_value = {"data": []}
+    # Test code that uses external_api
+```
+
+## Best Practices
+
+1. Use fixtures for test setup
+2. Parametrize for multiple test cases
+3. Mock external dependencies
+4. Use descriptive test names
+5. Keep tests independent
+
+## Common Pitfalls
+
+- **Shared state**: Use fresh fixtures
+- **Over-mocking**: Only mock boundaries
+- **Slow tests**: Use markers for slow tests

.claude/skills/testing/vitest/SKILL.md

@@ -0,0 +1,89 @@
+# Vitest
+
+## Description
+
+Modern JavaScript/TypeScript testing with Vitest including mocking and coverage.
+
+## When to Use
+
+- Testing JavaScript/TypeScript
+- React component testing
+- Unit and integration tests
+
+---
+
+## Core Patterns
+
+### Basic Tests
+
+```typescript
+import { describe, it, expect } from 'vitest';
+
+describe('math', () => {
+  it('should add numbers', () => {
+    expect(1 + 1).toBe(2);
+  });
+
+  it('should throw on invalid input', () => {
+    expect(() => divide(1, 0)).toThrow('Division by zero');
+  });
+});
+```
+
+### Mocking
+
+```typescript
+import { vi, describe, it, expect } from 'vitest';
+
+// Mock module
+vi.mock('./api', () => ({
+  fetchUser: vi.fn().mockResolvedValue({ id: 1 })
+}));
+
+// Mock function
+const callback = vi.fn();
+callback('arg');
+expect(callback).toHaveBeenCalledWith('arg');
+```
+
+### Async Tests
+
+```typescript
+it('should fetch data', async () => {
+  const data = await fetchData();
+  expect(data).toEqual({ id: 1 });
+});
+
+it('should reject on error', async () => {
+  await expect(fetchData()).rejects.toThrow('Error');
+});
+```
+
+### React Testing
+
+```typescript
+import { render, screen } from '@testing-library/react';
+import { userEvent } from '@testing-library/user-event';
+
+it('should handle click', async () => {
+  const onClick = vi.fn();
+  render(<Button onClick={onClick}>Click</Button>);
+
+  await userEvent.click(screen.getByRole('button'));
+  expect(onClick).toHaveBeenCalled();
+});
+```
+
+## Best Practices
+
+1. Use describe blocks for grouping
+2. Prefer async/await for async tests
+3. Use userEvent over fireEvent
+4. Mock at module boundaries
+5. Clean up after tests
+
+## Common Pitfalls
+
+- **Not awaiting async**: Always await promises
+- **Stale mocks**: Clear mocks between tests
+- **Testing implementation**: Test behavior