Test Specialist

export default async function test_specialist(input) {
  console.log("🧠 Running skill: test-specialist");
  
  // TODO: implement actual logic for this skill
  return {
    message: "Skill 'test-specialist' executed successfully!",
    input
  };
}


{
  "name": "@ai-labs-claude-skills/test-specialist",
  "version": "1.0.0",
  "description": "Claude AI skill: test-specialist",
  "main": "index.js",
  "files": [
    "."
  ],
  "license": "MIT",
  "author": "AI Labs"
}

# Bug Analysis and Debugging Framework

## Systematic Bug Analysis Approach

### 1. Reproduction
First, reliably reproduce the bug:
- Identify exact steps to trigger the issue
- Determine required environment/state
- Document inputs that cause the failure
- Note expected vs actual behavior

### 2. Isolation
Narrow down the problem:
- Binary search through the code path
- Remove unrelated code/dependencies
- Create minimal reproduction case
- Identify the smallest failing unit

### 3. Root Cause Analysis
Determine the underlying cause:
- Trace execution flow
- Check assumptions and preconditions
- Review recent changes (git blame, git log)
- Look for similar patterns in codebase

### 4. Fix Implementation
Implement the solution:
- Write a failing test first
- Implement the fix
- Verify test passes
- Check for similar issues elsewhere

### 5. Validation
Ensure the fix is complete:
- Run full test suite
- Test edge cases
- Verify no regressions
- Update documentation if needed

## Bug Categories and Detection

### Logic Errors

**Symptoms:**
- Incorrect calculations
- Wrong conditional branches taken
- Unexpected state transitions
- Data corruption

**Detection Strategies:**
```typescript
// Add assertions to verify invariants
function transfer(from: Account, to: Account, amount: number) {
  const beforeTotal = from.balance + to.balance;

  from.balance -= amount;
  to.balance += amount;

  const afterTotal = from.balance + to.balance;
  console.assert(beforeTotal === afterTotal, 'Balance mismatch');
}

// Unit tests for all branches
test.each([
  [100, 50, true],   // Normal case
  [100, 100, true],  // Exact balance
  [100, 101, false], // Insufficient funds
  [100, 0, false],   // Zero amount
  [100, -50, false], // Negative amount
])('transfer validation', (balance, amount, shouldSucceed) => {
  // Test implementation
});
```

### Race Conditions

**Symptoms:**
- Intermittent failures
- Tests pass/fail randomly
- Different behavior in production vs development
- Issues under load

**Detection Strategies:**
```typescript
// Test concurrent operations
test('handles concurrent updates correctly', async () => {
  const promises = Array.from({ length: 100 }, () =>
    incrementCounter()
  );

  await Promise.all(promises);
  expect(getCounter()).toBe(100);
});

// Add delays to expose timing issues
test('handles async race condition', async () => {
  const result1 = fetchData();
  await new Promise(resolve => setTimeout(resolve, 10));
  const result2 = fetchData();

  await expect(Promise.all([result1, result2])).resolves.toBeTruthy();
});
```

### Memory Leaks

**Symptoms:**
- Increasing memory usage over time
- Application slowdown
- Out of memory errors
- Event listeners not cleaned up

**Detection Strategies:**
```typescript
// Test for cleanup
test('cleans up event listeners', () => {
  const component = new Component();
  const listenerCount = getEventListenerCount();

  component.mount();
  expect(getEventListenerCount()).toBeGreaterThan(listenerCount);

  component.unmount();
  expect(getEventListenerCount()).toBe(listenerCount);
});

// Monitor memory in long-running tests
test('does not leak memory', async () => {
  const initialMemory = process.memoryUsage().heapUsed;

  for (let i = 0; i < 1000; i++) {
    await performOperation();
  }

  // Force garbage collection if available
  if (global.gc) global.gc();

  const finalMemory = process.memoryUsage().heapUsed;
  const growth = finalMemory - initialMemory;

  // Allow some growth but not linear with ite