debugging

Files (1)

• SKILL.md

SKILL.md (first lines)

# Debugging Skill

## Overview
Systematic debugging skill for root cause analysis, error tracing, performance profiling, and memory leak detection with comprehensive debugging strategies.

## Features
- Root cause analysis
- Error tracing and stack trace analysis
- Performance profiling
- Memory leak detection
- Debug visualization
- Automated debugging workflows

## Usage Examples

### Root Cause Analysis
```bash
/debugging analyze --error "Traceback" --file app.py
```

### Performance Profiling
```bash
/debugging profile --target app.py --duration 30
```

### Memory Leak Detection
```bash
/debugging memory --target app.py --iterations 100
```

## Implementation

### Root Cause Analyzer
```python
class RootCauseAnalyzer:
    """Analyzes and identifies root causes of errors"""

    def analyze_error_trace(self, error_trace):
        """Parse and analyze error traceback"""
        # Parse stack trace
        # Identify error location
        # Determine error type
        # Suggest root causes
        pass

    def categorize_error(self, error):
        """Categorize error type and severity"""
        categories = {
            'syntax': 'Syntax error',
            'runtime': 'Runtime error',
            'logic': 'Logic error',
            'resource': 'Resource error',
            'network': 'Network error',
            'security': 'Security error'
        }
        # Error categorization logic
        pass

    def suggest_solutions(self, error_type, context):
        """Provide solutions for identified errors"""
        # Solution database lookup
        # Context-aware suggestions
        # Implementation guidance
        pass
```

### Error Tracer
```python
class ErrorTracer:
    """Traces error execution paths"""

    def trace_execution(self, error_point):
        """Trace execution path to error point"""
        # Execution path reconstruction
        # Variable state analysis
        # Control flow tracking
        pass

    def create_error_report(self, error_data):
        """Generate comprehensive error report"""
        # Report formatting
        # Error visualization
        # Resolution steps
        pass

    def monitor_errors(self, threshold=10):
        """Monitor error frequency and patterns"""
        # Error frequency analysis
        # Pattern detection
        # Alert generation
        pass
```

### Performance Profiler
```python
class PerformanceProfiler:
    """Profiles application performance"""

    def profile_function(self, func, *args, **kwargs):
        """Profile individual function performance"""
        import time
        import cProfile
        import io
        import pstats

        pr = cProfile.Profile()
        pr.enable()

        result = func(*args, **kwargs)

        pr.disable()

        s = io.StringIO()
        ps = pstats.Stats(pr, stream=s).sort_stats('cumulative')
        ps.print_stats()

        return {
            'result': result,
            'profile': s.getvalue()

From eroslifestyle/Claude-Orchestrator-AI-Evolution, MIT.

More from eroslifestyle/Claude-Orchestrator-AI-Evolution