Fix Error

Identify root cause and suggest proven solutions

Analyzes error messages to identify root causes, predict resolution time, and suggest proven fixes. Learns patterns from similar errors to provide immediate solutions.

Usage

/fix-error [options]

Options

• None: Standard error analysis
• --deep: Deep dive including dependencies and environment
• --preventive: Focus on preventing future occurrences
• --quick: Quick fixes only

Basic Examples

# Standard error analysis
npm run build 2>&1
/fix-error
"Analyze this build error and suggest fixes"

# Deep analysis mode
python app.py 2>&1
/fix-error --deep
"Find the root cause, including environment issues"

# Quick fixes only
cargo test 2>&1
/fix-error --quick
"Just give me a quick fix"

# Prevention-focused
./app 2>&1 | tail -50
/fix-error --preventive
"Fix this and help me prevent it next time"

Collaboration with Claude

# Analyze error logs
cat error.log
/fix-error
"What's causing this error and how do I fix it?"

# Resolve test failures
npm test 2>&1
/fix-error --quick
"These tests are failing - need a quick fix"

# Analyze stack traces
python script.py 2>&1
/fix-error --deep
"Dig into this stack trace and check for environment issues"

# Handle multiple errors
grep -E "ERROR|WARN" app.log | tail -20
/fix-error
"Sort these by priority and tell me how to fix each one"

Error Resolution Time Prediction

🚀 Immediate Fix (< 5 minutes)
├─ Typos, missing imports
├─ Environment variables not set
├─ Undefined variable references
└─ Predicted time: 2-5 minutes

⚡ Quick Fix (< 30 minutes)
├─ Dependency version conflicts
├─ Configuration file errors
├─ Type mismatches
└─ Predicted time: 10-30 minutes

🔧 Investigation Required (< 2 hours)
├─ Complex logic errors
├─ Async processing race conditions
├─ API integration issues
└─ Predicted time: 30 minutes-2 hours

🔬 Deep Analysis (Half day or more)
├─ Architecture-related issues
├─ Multi-system integration problems
├─ Performance degradation
└─ Predicted time: 4 hours-several days

Similar Error Pattern Database

Common Errors and Immediate Solutions
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

📊 "Cannot read property 'X' of undefined/null" (Frequency: Extremely High)
├─ Primary cause: Insufficient null checks on objects
├─ Resolution time: 5-10 minutes
└─ Solution: Add Optional chaining (?.) or null checks

📊 "ECONNREFUSED" / "ENOTFOUND" (Frequency: High)
├─ Primary cause: Service not running or URL misconfiguration
├─ Resolution time: 5-15 minutes
└─ Solution: Check service startup, environment variables

📊 "Module not found" / "Cannot resolve" (Frequency: High)
├─ Primary cause: Package not installed, incorrect path
├─ Resolution time: 2-5 minutes
└─ Solution: Run npm install, check relative paths

📊 "Unexpected token" / "SyntaxError" (Frequency: Medium)
├─ Primary cause: Bracket/quote mismatch, reserved word usage
├─ Resolution time: 2-10 minutes
└─ Solution: Check syntax highlighting, run linter

📊 "CORS policy" / "Access-Control-Allow-Origin" (Frequency: Medium)
├─ Primary cause: Insufficient CORS configuration on server
├─ Resolution time: 15-30 minutes
└─ Solution: Configure server CORS, setup proxy

📊 "Maximum call stack size exceeded" (Frequency: Low)
├─ Primary cause: Infinite loops/recursion, circular references
├─ Resolution time: 30 minutes-2 hours
└─ Solution: Check recursion termination conditions, resolve circular references

Error Analysis Priority Matrix

Analysis Process

Phase 1: Error Information Collection

🔴 Must have:
- Full error message
- Stack trace
- Steps to reproduce

🟡 Should have:
- Environment details (OS, versions, dependencies)
- Recent changes (git log, commits)
- Related logs

🟢 Nice to have:
- System resources
- Network state
- External services

Phase 2: Root Cause Analysis

1. Identify symptoms

   • Exact error message
   • When and how it happens
   • What's affected

2. Find root causes

   • Use 5 Whys analysis
   • Check dependencies
   • Compare environments

3. Test your theory

   • Create minimal repro
   • Isolate the issue
   • Confirm the cause

Phase 3: Solution Implementation

🔴 Quick fix (hotfix):
- Stop the bleeding
- Apply workarounds
- Get ready to deploy

🟡 Root cause fix:
- Fix the actual problem
- Add tests
- Update docs

🟢 Prevent future issues:
- Better error handling
- Add monitoring
- Improve CI/CD

Output Example

🚨 Error Analysis Report
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

📍 Error Overview
├─ Type: [Compilation/Runtime/Logical/Environmental]
├─ Urgency: 🔴 High / 🟡 Medium / 🟢 Low
├─ Impact Scope: [Feature name/Component]
└─ Reproducibility: [100% / Intermittent / Specific conditions]

🔍 Root Cause
├─ Direct Cause: [Specific cause]
├─ Background Factors: [Environment/Configuration/Dependencies]
└─ Trigger: [Occurrence conditions]

💡 Solutions
🔴 Immediate response:
1. [Specific fix command/code]
2. [Temporary workaround]

🟡 Fundamental solution:
1. [Essential fix method]
2. [Necessary refactoring]

🟢 Preventive measures:
1. [Error handling improvement]
2. [Add tests]
3. [Monitoring setup]

📝 Verification Procedure
1. [Method to confirm after applying fix]
2. [Test execution command]
3. [Operation check items]

Analysis Methods by Error Type

Compilation/Build Errors

# TypeScript type errors
Must check (high):
- tsconfig.json settings
- Presence of type definition files (.d.ts)
- Accuracy of import statements

# Rust lifetime errors
Must check (high):
- Ownership movement
- Reference validity periods
- Mutability conflicts

Runtime Errors

# Null/Undefined references
Must check (high):
- Insufficient optional chaining
- Initialization timing
- Waiting for async processing completion

# Memory-related errors
Must check (high):
- Heap dump acquisition
- GC log analysis
- Circular reference detection

Dependency Errors

# Version conflicts
Must check (high):
- Lock file consistency
- Peer dependencies requirements
- Transitive dependencies

# Module resolution errors
Must check (high):
- NODE_PATH settings
- Path alias configuration
- Symbolic links

Notes

• Absolutely prohibited: Making judgments based only on part of an error message, applying Stack Overflow solutions without verification
• Exception conditions: Temporary workarounds are only allowed under these 3 conditions:
  1. Emergency response in production environment (root solution required within 24 hours)
  2. External service failures (alternative means while waiting for recovery)
  3. Known framework bugs (waiting for fixed version release)
• Recommendation: Prioritize identifying root causes and avoid superficial fixes

Best Practices

1. Complete information collection: Check error messages from beginning to end
2. Reproducibility confirmation: Prioritize creating minimal reproduction code
3. Step-by-step approach: Start with small fixes and verify
4. Documentation: Record the solution process for knowledge sharing

Common Pitfalls

• Symptom treatment: Superficial fixes that miss root causes
• Overgeneralization: Widely applying solutions for specific cases
• Omitted verification: Not checking side effects after fixes
• Knowledge individualization: Not documenting solution methods

Related Commands

• /design-patterns: Analyze code structure issues and suggest patterns
• /tech-debt: Analyze root causes of errors from a technical debt perspective
• /analyzer: For cases requiring deeper root cause analysis