제27강: AI 기반 디버깅과 문제 해결 도구

스마트 디버깅 시스템

// debugger/AIDebugger.ts
import { CursorAI } from '@cursor/api';
import { SourceMapConsumer } from 'source-map';
import * as inspector from 'inspector';
import { AsyncLocalStorage } from 'async_hooks';

export class AIDebugger {
    private cursor: CursorAI;
    private session: inspector.Session;
    private executionContext: AsyncLocalStorage;
    private breakpoints: Map;
    private errorPatterns: ErrorPatternDatabase;

    constructor() {
        this.cursor = new CursorAI();
        this.session = new inspector.Session();
        this.session.connect();
        this.executionContext = new AsyncLocalStorage();
        this.breakpoints = new Map();
        this.errorPatterns = new ErrorPatternDatabase();
        this.setupDebugger();
    }

    private setupDebugger() {
        // 전역 에러 핸들러 설정
        process.on('uncaughtException', async (error, origin) => {
            await this.handleError(error, origin);
        });

        process.on('unhandledRejection', async (reason, promise) => {
            await this.handleRejection(reason, promise);
        });

        // 디버거 프로토콜 활성화
        this.session.post('Debugger.enable');
        this.session.post('Runtime.enable');
        this.session.post('Profiler.enable');
        
        // 브레이크포인트 이벤트 리스너
        this.session.on('Debugger.paused', async (params) => {
            await this.handleBreakpoint(params);
        });
    }

    async analyzeError(error: Error): Promise {
        const stackFrames = await this.parseStackTrace(error.stack!);
        const sourceCode = await this.extractRelevantCode(stackFrames);
        const executionHistory = this.getExecutionHistory();

        // AI로 에러 분석
        const prompt = `
다음 에러를 분석하고 해결 방안을 제시해주세요:

에러 메시지: ${error.message}
에러 타입: ${error.name}

스택 트레이스:
${error.stack}

관련 코드:
${sourceCode.map(s => `
파일: ${s.file}
라인 ${s.line}:
\`\`\`javascript
${s.code}
\`\`\`
`).join('\n')}

실행 컨텍스트:
${JSON.stringify(executionHistory, null, 2)}

다음을 포함해주세요:
1. 에러의 근본 원인
2. 구체적인 해결 방법
3. 재발 방지 방안
4. 관련된 다른 잠재적 문제
`;

        const analysis = await this.cursor.ai.generateCode(prompt);
        const parsedAnalysis = JSON.parse(analysis);

        return {
            error: {
                type: error.name,
                message: error.message,
                stack: stackFrames
            },
            rootCause: parsedAnalysis.rootCause,
            solutions: parsedAnalysis.solutions,
            preventiveMeasures: parsedAnalysis.preventiveMeasures,
            relatedIssues: parsedAnalysis.relatedIssues,
            confidence: this.calculateConfidence(parsedAnalysis)
        };
    }

    private async parseStackTrace(stack: string): Promise {
        const frames: StackFrame[] = [];
        const lines = stack.split('\n');
        
        for (const line of lines) {
            const match = line.match(/at\s+(.+?)\s+\((.+?):(\d+):(\d+)\)/);
            if (match) {
                const [, functionName, file, lineStr, columnStr] = match;
                const line = parseInt(lineStr);
                const column = parseInt(columnStr);
                
                // 소스맵 처리
                const originalPosition = await this.resolveSourceMap(file, line, column);
                
                frames.push({
                    functionName,
                    file: originalPosition.source || file,
                    line: originalPosition.line || line,
                    column: originalPosition.column || column,
                    source: await this.getSourceCode(originalPosition.source || file, originalPosition.line || line)
                });
            }
        }
        
        return frames;
    }

    async setSmartBreakpoint(condition: string): Promise {
        // AI로 브레이크포인트 조건 생성
        const prompt = `
다음 조건에 맞는 브레이크포인트 설정을 생성해주세요:

조건: ${condition}

다음 형식으로 제공해주세요:
- 파일 패턴
- 라인 번호 또는 함수명
- 조건식 (JavaScript)
- 수집할 데이터
`;

        const config = await this.cursor.ai.generateCode(prompt);
        const breakpointConfig = JSON.parse(config);

        // 브레이크포인트 설정
        const files = await this.findMatchingFiles(breakpointConfig.filePattern);
        
        for (const file of files) {
            const breakpoint = await this.createBreakpoint({
                file,
                line: breakpointConfig.line,
                condition: breakpointConfig.condition,
                dataCollection: breakpointConfig.dataCollection
            });
            
            this.breakpoints.set(breakpoint.id, breakpoint);
        }
    }

    private async handleBreakpoint(params: any): Promise {
        const callFrames = params.callFrames;
        const breakpointId = params.hitBreakpoints[0];
        const breakpoint = this.breakpoints.get(breakpointId);
        
        if (!breakpoint) return;

        // 실행 컨텍스트 수집
        const context = await this.collectExecutionContext(callFrames);
        
        // AI 분석
        const analysis = await this.analyzeBreakpointHit(breakpoint, context);
        
        // 조건부 계속 실행
        if (analysis.shouldContinue) {
            this.session.post('Debugger.resume');
        } else {
            // 문제 발견 - 상세 분석
            await this.performDeepAnalysis(context, analysis);
        }
    }

    async debugAsyncFlow(functionName: string): Promise {
        const traces: AsyncTrace[] = [];
        const errors: AsyncError[] = [];
        
        // 비동기 훅 설정
        const asyncHook = async_hooks.createHook({
            init(asyncId, type, triggerAsyncId) {
                if (this.shouldTrack(type)) {
                    traces.push({
                        asyncId,
                        type,
                        triggerAsyncId,
                        timestamp: Date.now(),
                        stack: new Error().stack
                    });
                }
            },
            before(asyncId) {
                const trace = traces.find(t => t.asyncId === asyncId);
                if (trace) {
                    trace.executionStart = Date.now();
                }
            },
            after(asyncId) {
                const trace = traces.find(t => t.asyncId === asyncId);
                if (trace) {
                    trace.executionEnd = Date.now();
                    trace.duration = trace.executionEnd - trace.executionStart!;
                }
            },
            destroy(asyncId) {
                const index = traces.findIndex(t => t.asyncId === asyncId);
                if (index !== -1) {
                    traces.splice(index, 1);
                }
            }
        });
        
        asyncHook.enable();
        
        // 함수 실행 추적
        try {
            await this.executeWithTracking(functionName);
        } catch (error) {
            errors.push({
                error,
                asyncId: async_hooks.executionAsyncId(),
                context: this.executionContext.getStore()
            });
        } finally {
            asyncHook.disable();
        }
        
        // 비동기 흐름 분석
        return this.analyzeAsyncFlow(traces, errors);
    }

    private async analyzeAsyncFlow(
        traces: AsyncTrace[], 
        errors: AsyncError[]
    ): Promise {
        // 비동기 체인 재구성
        const chains = this.reconstructAsyncChains(traces);
        
        // 병목 지점 식별
        const bottlenecks = chains
            .filter(chain => chain.totalDuration > 1000)
            .sort((a, b) => b.totalDuration - a.totalDuration);
        
        // 에러 전파 경로 추적
        const errorPaths = errors.map(error => 
            this.traceErrorPropagation(error, traces)
        );
        
        // AI 분석
        const prompt = `
비동기 실행 흐름을 분석해주세요:

비동기 체인:
${JSON.stringify(chains, null, 2)}

에러 발생:
${JSON.stringify(errorPaths, null, 2)}

다음을 분석해주세요:
1. 비효율적인 비동기 패턴
2. 잠재적 레이스 컨디션
3. 에러 처리 누락
4. 성능 개선 기회
`;

        const analysis = await this.cursor.ai.generateCode(prompt);
        
        return {
            chains,
            bottlenecks,
            errors: errorPaths,
            recommendations: JSON.parse(analysis)
        };
    }

    async timeTravel(targetState: string): Promise {
        // 실행 히스토리에서 타겟 상태 찾기
        const snapshot = await this.findStateSnapshot(targetState);
        
        if (!snapshot) {
            throw new Error('해당 상태를 찾을 수 없습니다.');
        }
        
        // 상태 복원
        await this.restoreState(snapshot);
        
        // 실행 경로 재현
        const executionPath = await this.replayExecution(snapshot);
        
        return {
            snapshot,
            executionPath,
            variables: snapshot.variables,
            callStack: snapshot.callStack
        };
    }
}

// 분산 시스템 디버거
export class DistributedDebugger {
    private debuggers: Map;
    private correlator: TraceCorrelator;
    private cursor: CursorAI;

    constructor() {
        this.debuggers = new Map();
        this.correlator = new TraceCorrelator();
        this.cursor = new CursorAI();
    }

    async traceDistributedRequest(requestId: string): Promise {
        const traces: ServiceTrace[] = [];
        
        // 모든 서비스에서 트레이스 수집
        for (const [service, debugger] of this.debuggers) {
            const serviceTraces = await debugger.getTracesForRequest(requestId);
            traces.push({
                service,
                traces: serviceTraces,
                logs: await this.getServiceLogs(service, requestId),
                metrics: await this.getServiceMetrics(service, requestId)
            });
        }
        
        // 트레이스 상관관계 분석
        const correlation = await this.correlator.correlate(traces);
        
        // 분산 시스템 문제 진단
        const diagnosis = await this.diagnoseDistributedIssues(correlation);
        
        return {
            requestId,
            services: traces,
            correlation,
            diagnosis,
            visualization: this.generateTraceVisualization(correlation)
        };
    }

    private async diagnoseDistributedIssues(
        correlation: TraceCorrelation
    ): Promise {
        const issues: DistributedIssue[] = [];
        
        // 1. 타임아웃 캐스케이드 검사
        const timeoutCascades = this.detectTimeoutCascades(correlation);
        issues.push(...timeoutCascades);
        
        // 2. 서비스 간 불일치 검사
        const inconsistencies = this.detectInconsistencies(correlation);
        issues.push(...inconsistencies);
        
        // 3. 분산 데드락 검사
        const deadlocks = await this.detectDistributedDeadlocks(correlation);
        issues.push(...deadlocks);
        
        // AI 진단
        const prompt = `
분산 시스템 트레이스를 분석해주세요:

서비스 수: ${correlation.services.length}
총 실행 시간: ${correlation.totalDuration}ms
에러 발생: ${correlation.errors.length}

트레이스 데이터:
${JSON.stringify(correlation, null, 2)}

다음을 진단해주세요:
1. 근본 원인 서비스
2. 에러 전파 경로
3. 성능 병목 지점
4. 해결 우선순위
5. 장기적 개선 방안
`;

        const aiDiagnosis = await this.cursor.ai.generateCode(prompt);
        
        return {
            issues,
            rootCause: JSON.parse(aiDiagnosis).rootCause,
            propagationPath: JSON.parse(aiDiagnosis).propagationPath,
            recommendations: JSON.parse(aiDiagnosis).recommendations
        };
    }
}

// 예측적 버그 탐지
export class PredictiveBugDetector {
    private cursor: CursorAI;
    private codeAnalyzer: CodeAnalyzer;
    private historicalBugs: BugDatabase;
    private ml: MachineLearningEngine;

    async analyzeFutureRisks(codebase: string): Promise {
        const risks: PotentialBug[] = [];
        
        // 1. 정적 분석으로 위험 패턴 탐지
        const staticRisks = await this.performStaticAnalysis(codebase);
        risks.push(...staticRisks);
        
        // 2. 과거 버그 패턴과 비교
        const historicalPatterns = await this.matchHistoricalPatterns(codebase);
        risks.push(...historicalPatterns);
        
        // 3. ML 모델로 잠재적 버그 예측
        const mlPredictions = await this.ml.predictBugs(codebase);
        risks.push(...mlPredictions);
        
        // 4. AI 종합 분석
        const aiAnalysis = await this.performAIRiskAnalysis(codebase, risks);
        
        return {
            risks: risks.sort((a, b) => b.probability - a.probability),
            criticalPaths: aiAnalysis.criticalPaths,
            preventiveMeasures: aiAnalysis.preventiveMeasures,
            testSuggestions: await this.generateTestSuggestions(risks)
        };
    }

    private async performStaticAnalysis(codebase: string): Promise {
        const bugs: PotentialBug[] = [];
        const files = await this.getSourceFiles(codebase);
        
        for (const file of files) {
            const ast = await this.codeAnalyzer.parse(file);
            
            // 위험한 패턴 검사
            ast.traverse({
                // Null/Undefined 참조 위험
                MemberExpression(path) {
                    if (!path.node.optional && this.isNullableType(path.node.object)) {
                        bugs.push({
                            type: 'null-reference',
                            file: file.path,
                            line: path.node.loc.start.line,
                            probability: 0.7,
                            impact: 'runtime-error',
                            description: 'Null 또는 undefined 참조 가능성',
                            suggestion: 'Optional chaining (?.) 사용'
                        });
                    }
                },
                
                // 무한 루프 위험
                WhileStatement(path) {
                    if (!this.hasBreakCondition(path.node)) {
                        bugs.push({
                            type: 'infinite-loop',
                            file: file.path,
                            line: path.node.loc.start.line,
                            probability: 0.8,
                            impact: 'performance',
                            description: '무한 루프 가능성',
                            suggestion: '명확한 종료 조건 추가'
                        });
                    }
                },
                
                // 메모리 누수 위험
                CallExpression(path) {
                    if (this.isEventListenerAdd(path.node) && 
                        !this.hasCorrespondingRemove(path)) {
                        bugs.push({
                            type: 'memory-leak',
                            file: file.path,
                            line: path.node.loc.start.line,
                            probability: 0.6,
                            impact: 'memory',
                            description: '이벤트 리스너 메모리 누수',
                            suggestion: 'removeEventListener 추가'
                        });
                    }
                }
            });
        }
        
        return bugs;
    }

    private async performAIRiskAnalysis(
        codebase: string, 
        risks: PotentialBug[]
    ): Promise {
        const prompt = `
코드베이스의 잠재적 위험을 분석해주세요:

발견된 위험 요소:
${JSON.stringify(risks.slice(0, 20), null, 2)}

전체 통계:
- 총 위험 요소: ${risks.length}
- 높음: ${risks.filter(r => r.probability > 0.7).length}
- 중간: ${risks.filter(r => r.probability >= 0.4 && r.probability <= 0.7).length}
- 낮음: ${risks.filter(r => r.probability < 0.4).length}

다음을 분석해주세요:
1. 가장 위험한 코드 경로
2. 시스템 전체에 미칠 영향
3. 우선적으로 수정해야 할 항목
4. 예방 전략
5. 테스트 커버리지 강화 방안
`;

        const response = await this.cursor.ai.generateCode(prompt);
        return JSON.parse(response);
    }

    async generateTestSuggestions(risks: PotentialBug[]): Promise {
        const suggestions: TestSuggestion[] = [];
        
        // 위험별 테스트 케이스 생성
        for (const risk of risks.slice(0, 10)) { // 상위 10개
            const prompt = `
다음 잠재적 버그를 검증하는 테스트 케이스를 생성해주세요:

버그 유형: ${risk.type}
위치: ${risk.file}:${risk.line}
설명: ${risk.description}
확률: ${risk.probability}

테스트 케이스를 Jest 형식으로 작성해주세요.
`;

            const testCode = await this.cursor.ai.generateCode(prompt);
            
            suggestions.push({
                risk,
                testCode,
                framework: 'jest',
                priority: risk.probability * this.getImpactScore(risk.impact)
            });
        }
        
        return suggestions.sort((a, b) => b.priority - a.priority);
    }
}

// 실시간 디버깅 UI
export class DebuggerUI {
    private debugger: AIDebugger;
    private websocket: WebSocket;
    private visualization: DebugVisualization;

    constructor() {
        this.debugger = new AIDebugger();
        this.visualization = new DebugVisualization();
        this.setupRealtimeDebugging();
    }

    private setupRealtimeDebugging() {
        // WebSocket으로 실시간 디버깅 정보 전송
        this.websocket.on('connection', (socket) => {
            // 실시간 변수 감시
            socket.on('watch', async (expression) => {
                const watcher = await this.debugger.createWatcher(expression);
                watcher.on('change', (value) => {
                    socket.emit('watchUpdate', { expression, value });
                });
            });
            
            // 조건부 브레이크포인트
            socket.on('conditionalBreak', async (condition) => {
                await this.debugger.setSmartBreakpoint(condition);
            });
            
            // 시간 여행 디버깅
            socket.on('timeTravel', async (targetState) => {
                const result = await this.debugger.timeTravel(targetState);
                socket.emit('timeTravelResult', result);
            });
        });
    }

    async visualizeExecutionFlow(functionName: string): Promise {
        const flow = await this.debugger.traceExecutionFlow(functionName);
        
        return `

    
실행 흐름: ${functionName}
    
    

        ${this.visualization.generateFlowDiagram(flow)}
    
    
    

        
성능 메트릭
        

            
총 실행 시간: ${flow.totalDuration}ms
            
함수 호출 수: ${flow.functionCalls}
            
메모리 할당: ${flow.memoryAllocated}MB
        
    
    
    

        
병목 지점
        ${flow.bottlenecks.map(b => `
            

                ${b.location}
                ${b.duration}ms
                ${b.percentage}%
            
        `).join('')}
    
    
    

        
AI 인사이트
        ${flow.insights.map(insight => `
            

                
                ${insight.message}
            
        `).join('')}
    

        `;
    }
}

// 버그 자동 수정
export class AutoBugFixer {
    private cursor: CursorAI;
    private testRunner: TestRunner;
    private versionControl: VersionControl;

    async attemptAutoFix(bug: DetectedBug): Promise {
        console.log(`🔧 자동 수정 시도: ${bug.type}`);
        
        // 1. 버그 유형별 수정 전략 선택
        const strategy = this.selectFixStrategy(bug);
        
        // 2. AI로 수정 코드 생성
        const fixedCode = await this.generateFix(bug, strategy);
        
        // 3. 수정 적용 (임시)
        const backup = await this.createBackup(bug.file);
        await this.applyFix(bug.file, fixedCode);
        
        // 4. 테스트 실행
        const testResult = await this.testRunner.run();
        
        if (testResult.passed) {
            // 5. 수정 확정
            await this.versionControl.commit(
                `fix: ${bug.type} in ${bug.file}:${bug.line}`,
                fixedCode
            );
            
            return {
                success: true,
                fixedCode,
                testsPassed: true,
                confidence: 0.9
            };
        } else {
            // 롤백
            await this.restore(backup);
            
            return {
                success: false,
                reason: 'Tests failed after fix',
                testErrors: testResult.errors
            };
        }
    }

    private async generateFix(bug: DetectedBug, strategy: FixStrategy): Promise {
        const context = await this.gatherContext(bug);
        
        const prompt = `
다음 버그를 수정해주세요:

버그 정보:
- 유형: ${bug.type}
- 위치: ${bug.file}:${bug.line}
- 설명: ${bug.description}

원본 코드:
\`\`\`javascript
${context.originalCode}
\`\`\`

컨텍스트:
${JSON.stringify(context.surroundingCode, null, 2)}

수정 전략: ${strategy.approach}

요구사항:
1. 버그를 완전히 수정
2. 기존 기능을 보존
3. 코드 스타일 유지
4. 성능 저하 없음
`;

        const fixedCode = await this.cursor.ai.generateCode(prompt);
        return fixedCode;
    }
}