Debugger

# Debugger

An advanced debugging specialist that helps diagnose and resolve code issues systematically.

## When This Skill Activates

Activates when you:
- Report an error or bug
- Mention "debug this" or "help debug"
- Describe unexpected behavior
- Ask why something isn't working

## Debugging Process

### Phase 1: Understand the Problem

1. **Reproduce the issue**
   - What are the exact steps to reproduce?
   - What is the expected behavior?
   - What is the actual behavior?
   - What error messages appear?

2. **Gather context**
   ```bash
   # Check recent changes
   git log --oneline -10

   # Check error logs
   tail -f logs/error.log

   # Check environment
   env | grep -i debug
   ```

### Phase 2: Isolate the Issue

1. **Locate the error source**
   - Stack trace analysis
   - Error code lookup
   - Log correlation

2. **Narrow down scope**
   - Binary search (comment out half)
   - Minimize reproduction case
   - Identify affected components

### Phase 3: Analyze the Root Cause

#### Common Error Categories

| Category | Symptoms | Investigation Steps |
|----------|----------|---------------------|
| **Null/Undefined** | "Cannot read X of undefined" | Trace the variable origin |
| **Type Errors** | "X is not a function" | Check actual vs expected type |
| **Async Issues** | Race conditions, timing | Check promise handling, async/await |
| **State Issues** | Stale data, wrong state | Trace state mutations |
| **Network** | Timeouts, connection refused | Check endpoints, CORS, auth |
| **Environment** | Works locally, not in prod | Compare env vars, versions |
| **Memory** | Leaks, OOM | Profile memory usage |
| **Concurrency** | Deadlocks, race conditions | Check locks, shared state |

### Phase 4: Form Hypotheses

For each potential cause:
1. Form a hypothesis
2. Create a test to validate
3. Run the test
4. Confirm or reject

### Phase 5: Fix and Verify

1. **Implement the fix**
2. **Add logging if needed**
3. **Test the fix**
4. **Add regression test**

## Debugging Commands

### General Debugging

```bash
# Find recently modified files
find . -type f -mtime -1 -name "*.js" -o -name "*.ts" -o -name "*.py"

# Grep for error patterns
grep -r "ERROR\|FATAL\|Exception" logs/

# Search for suspicious patterns
grep -r "TODO\|FIXME\|XXX" src/

# Check for console.log left in code
grep -r "console\.log\|debugger" src/
```

### Language-Specific

**JavaScript/TypeScript:**
```bash
# Run with debug output
NODE_DEBUG=* node app.js

# Check syntax
node -c file.js

# Run tests in debug mode
npm test -- --inspect-brk
```

**Python:**
```bash
# Run with pdb
python -m pdb script.py

# Check syntax
python -m py_compile script.py

# Verbose mode
python -v script.py
```

**Go:**
```bash
# Race detection
go run -race main.go

# Debug build
go build -gcflags="-N -l"

# Profile
go test -cpuprofile=cpu.prof
```

## Common Debugging Patterns

### Pattern 1: Divide and Conquer

```python
# When you don't know where the bug is:
def process():
    step1()
    step2()
    step3()
    step4()

# Comment out half:
def process():
    step1()
    # step2()
    # step3()
    # step4()

# If bug disappears, uncomment half of commented:
def process():
    step1()
    step2()
    # step3()
    # step4()

# Continue until you isolate the bug
```

### Pattern 2: Add Logging

```typescript
// Before (mysterious failure):
async function getUser(id: string) {
  const user = await db.find(id);
  return transform(user);
}

// After (with logging):
async function getUser(id: stri