제23강: AI 코드 리뷰와 품질 관리

코드 리뷰 자동화 시스템

// .cursor/code-review-bot.js
import { CursorAI } from '@cursor/api';
import { GitHubAPI } from '@octokit/rest';
import { ESLint } from 'eslint';
import { parse } from '@babel/parser';
import traverse from '@babel/traverse';

class AICodeReviewBot {
    constructor(config) {
        this.cursor = new CursorAI(config.cursorApiKey);
        this.github = new GitHubAPI({ auth: config.githubToken });
        this.eslint = new ESLint({
            baseConfig: config.eslintConfig,
            useEslintrc: true
        });
        
        this.reviewRules = {
            complexity: {
                maxCyclomaticComplexity: 10,
                maxCognitiveComplexity: 15,
                maxLinesPerFunction: 50,
                maxParameters: 4
            },
            security: {
                checkSQLInjection: true,
                checkXSS: true,
                checkSensitiveData: true,
                checkDependencies: true
            },
            performance: {
                checkN1Queries: true,
                checkMemoryLeaks: true,
                checkAsyncPatterns: true,
                checkBundleSize: true
            },
            maintainability: {
                checkDuplication: true,
                checkNaming: true,
                checkDocumentation: true,
                checkTestCoverage: true
            }
        };
    }

    async reviewPullRequest(owner, repo, pullNumber) {
        const pr = await this.github.pulls.get({
            owner,
            repo,
            pull_number: pullNumber
        });

        const files = await this.github.pulls.listFiles({
            owner,
            repo,
            pull_number: pullNumber
        });

        const reviews = [];
        
        for (const file of files.data) {
            if (this.shouldReviewFile(file.filename)) {
                const review = await this.reviewFile(file);
                if (review.issues.length > 0) {
                    reviews.push(review);
                }
            }
        }

        return this.generateReviewReport(reviews);
    }

    async reviewFile(file) {
        const content = await this.getFileContent(file);
        
        const reviews = {
            filename: file.filename,
            issues: [],
            suggestions: [],
            metrics: {}
        };

        // 1. ESLint 검사
        const lintResults = await this.runESLint(content, file.filename);
        reviews.issues.push(...this.formatLintIssues(lintResults));

        // 2. 복잡도 분석
        const complexityIssues = await this.analyzeComplexity(content);
        reviews.issues.push(...complexityIssues);
        
        // 3. 보안 취약점 검사
        const securityIssues = await this.checkSecurity(content);
        reviews.issues.push(...securityIssues);
        
        // 4. AI 기반 코드 분석
        const aiReview = await this.getAIReview(content, file.filename);
        reviews.suggestions.push(...aiReview.suggestions);
        
        // 5. 성능 분석
        const performanceIssues = await this.analyzePerformance(content);
        reviews.issues.push(...performanceIssues);

        // 6. 코드 메트릭스 수집
        reviews.metrics = await this.collectMetrics(content);

        return reviews;
    }

    async analyzeComplexity(code) {
        const issues = [];
        const ast = parse(code, {
            sourceType: 'module',
            plugins: ['jsx', 'typescript']
        });

        traverse(ast, {
            FunctionDeclaration: (path) => {
                const complexity = this.calculateCyclomaticComplexity(path.node);
                if (complexity > this.reviewRules.complexity.maxCyclomaticComplexity) {
                    issues.push({
                        line: path.node.loc.start.line,
                        severity: 'warning',
                        message: `함수 '${path.node.id.name}'의 순환 복잡도가 ${complexity}입니다. (최대: ${this.reviewRules.complexity.maxCyclomaticComplexity})`,
                        suggestion: '함수를 더 작은 단위로 분리하는 것을 고려해보세요.'
                    });
                }
            },
            ArrowFunctionExpression: (path) => {
                const lineCount = path.node.loc.end.line - path.node.loc.start.line;
                if (lineCount > this.reviewRules.complexity.maxLinesPerFunction) {
                    issues.push({
                        line: path.node.loc.start.line,
                        severity: 'warning',
                        message: `함수가 너무 깁니다 (${lineCount}줄). 최대 ${this.reviewRules.complexity.maxLinesPerFunction}줄을 권장합니다.`,
                        suggestion: '함수를 더 작은 단위로 분리하세요.'
                    });
                }
            }
        });

        return issues;
    }

    async checkSecurity(code) {
        const issues = [];
        
        // SQL Injection 검사
        const sqlPatterns = [
            /query\s*\(\s*['"`].*\$\{.*\}.*['"`]\s*\)/gi,
            /execute\s*\(\s*['"`].*\+.*['"`]\s*\)/gi
        ];
        
        sqlPatterns.forEach(pattern => {
            const matches = code.matchAll(pattern);
            for (const match of matches) {
                const line = code.substring(0, match.index).split('\n').length;
                issues.push({
                    line,
                    severity: 'error',
                    message: 'SQL Injection 취약점이 발견되었습니다.',
                    suggestion: 'Prepared statements나 파라미터화된 쿼리를 사용하세요.'
                });
            }
        });

        // XSS 검사
        const xssPatterns = [
            /innerHTML\s*=\s*[^'"`]*\$/gi,
            /dangerouslySetInnerHTML/gi
        ];
        
        xssPatterns.forEach(pattern => {
            const matches = code.matchAll(pattern);
            for (const match of matches) {
                const line = code.substring(0, match.index).split('\n').length;
                issues.push({
                    line,
                    severity: 'warning',
                    message: 'XSS 취약점 가능성이 있습니다.',
                    suggestion: 'textContent를 사용하거나 입력값을 적절히 이스케이프하세요.'
                });
            }
        });

        // 민감한 정보 노출 검사
        const sensitivePatterns = [
            /api[_-]?key\s*[:=]\s*['"`][^'"`]+['"`]/gi,
            /password\s*[:=]\s*['"`][^'"`]+['"`]/gi,
            /secret\s*[:=]\s*['"`][^'"`]+['"`]/gi
        ];
        
        sensitivePatterns.forEach(pattern => {
            const matches = code.matchAll(pattern);
            for (const match of matches) {
                const line = code.substring(0, match.index).split('\n').length;
                issues.push({
                    line,
                    severity: 'error',
                    message: '하드코딩된 민감한 정보가 발견되었습니다.',
                    suggestion: '환경 변수나 보안 저장소를 사용하세요.'
                });
            }
        });

        return issues;
    }

    async getAIReview(code, filename) {
        const prompt = `
다음 코드를 리뷰하고 개선 사항을 제안해주세요:

파일명: ${filename}
코드:
\`\`\`
${code}
\`\`\`

다음 측면을 중점적으로 검토해주세요:
1. 코드 품질과 가독성
2. 성능 최적화 가능성
3. 잠재적 버그나 엣지 케이스
4. 더 나은 패턴이나 관용구 사용
5. 테스트 가능성과 유지보수성

각 제안사항에 대해 구체적인 코드 예시를 제공해주세요.
`;

        const response = await this.cursor.chat.sendMessage(prompt);
        return this.parseAIResponse(response);
    }

    async analyzePerformance(code) {
        const issues = [];
        
        // N+1 쿼리 패턴 검사
        const n1Patterns = [
            /\.map\s*\(.*await.*\)/gi,
            /for\s*\(.*\)\s*{[^}]*await[^}]*}/gi
        ];
        
        n1Patterns.forEach(pattern => {
            const matches = code.matchAll(pattern);
            for (const match of matches) {
                const line = code.substring(0, match.index).split('\n').length;
                issues.push({
                    line,
                    severity: 'warning',
                    message: 'N+1 쿼리 패턴이 감지되었습니다.',
                    suggestion: 'Promise.all()을 사용하거나 쿼리를 배치로 처리하세요.'
                });
            }
        });

        // 메모리 누수 가능성 검사
        const memoryLeakPatterns = [
            /addEventListener[^}]*(?!removeEventListener)/gi,
            /setInterval\s*\([^)]*\)/gi
        ];
        
        memoryLeakPatterns.forEach(pattern => {
            const matches = code.matchAll(pattern);
            for (const match of matches) {
                const line = code.substring(0, match.index).split('\n').length;
                issues.push({
                    line,
                    severity: 'warning',
                    message: '메모리 누수 가능성이 있습니다.',
                    suggestion: '적절한 cleanup 로직을 추가하세요.'
                });
            }
        });

        return issues;
    }

    async collectMetrics(code) {
        const lines = code.split('\n');
        const ast = parse(code, {
            sourceType: 'module',
            plugins: ['jsx', 'typescript']
        });

        let functionCount = 0;
        let classCount = 0;
        let maxDepth = 0;
        let currentDepth = 0;

        traverse(ast, {
            enter(path) {
                currentDepth++;
                maxDepth = Math.max(maxDepth, currentDepth);
            },
            exit() {
                currentDepth--;
            },
            FunctionDeclaration() {
                functionCount++;
            },
            ArrowFunctionExpression() {
                functionCount++;
            },
            ClassDeclaration() {
                classCount++;
            }
        });

        return {
            lines: lines.length,
            functions: functionCount,
            classes: classCount,
            maxDepth,
            commentRatio: this.calculateCommentRatio(code),
            duplicateLines: this.findDuplicateLines(lines)
        };
    }

    calculateCommentRatio(code) {
        const commentLines = (code.match(/\/\/.*$/gm) || []).length +
                           (code.match(/\/\*[\s\S]*?\*\//g) || [])
                               .reduce((sum, comment) => sum + comment.split('\n').length, 0);
        const totalLines = code.split('\n').length;
        return (commentLines / totalLines * 100).toFixed(2);
    }

    findDuplicateLines(lines) {
        const lineMap = new Map();
        let duplicates = 0;
        
        lines.forEach((line, index) => {
            const trimmed = line.trim();
            if (trimmed && trimmed.length > 10) {
                if (lineMap.has(trimmed)) {
                    duplicates++;
                } else {
                    lineMap.set(trimmed, index);
                }
            }
        });
        
        return duplicates;
    }

    async generateReviewReport(reviews) {
        const totalIssues = reviews.reduce((sum, r) => sum + r.issues.length, 0);
        const criticalIssues = reviews.reduce((sum, r) => 
            sum + r.issues.filter(i => i.severity === 'error').length, 0);
        
        const report = {
            summary: {
                totalFiles: reviews.length,
                totalIssues,
                criticalIssues,
                warnings: totalIssues - criticalIssues,
                overallScore: this.calculateOverallScore(reviews)
            },
            fileReviews: reviews,
            recommendations: await this.generateRecommendations(reviews)
        };

        return report;
    }

    calculateOverallScore(reviews) {
        let score = 100;
        
        reviews.forEach(review => {
            review.issues.forEach(issue => {
                if (issue.severity === 'error') {
                    score -= 10;
                } else if (issue.severity === 'warning') {
                    score -= 5;
                }
            });
        });
        
        return Math.max(0, score);
    }

    async generateRecommendations(reviews) {
        const recommendations = [];
        
        // 복잡도가 높은 파일들
        const complexFiles = reviews.filter(r => 
            r.metrics && r.metrics.maxDepth > 5
        );
        
        if (complexFiles.length > 0) {
            recommendations.push({
                type: 'refactoring',
                priority: 'high',
                message: `${complexFiles.length}개 파일의 복잡도가 높습니다. 리팩토링을 고려하세요.`,
                files: complexFiles.map(f => f.filename)
            });
        }
        
        // 테스트 커버리지가 낮은 파일들
        const lowCoverageFiles = reviews.filter(r => 
            r.metrics && r.metrics.testCoverage < 80
        );
        
        if (lowCoverageFiles.length > 0) {
            recommendations.push({
                type: 'testing',
                priority: 'medium',
                message: `${lowCoverageFiles.length}개 파일의 테스트 커버리지가 낮습니다.`,
                files: lowCoverageFiles.map(f => f.filename)
            });
        }
        
        return recommendations;
    }
}

// GitHub Actions 통합
export async function runCodeReview() {
    const bot = new AICodeReviewBot({
        cursorApiKey: process.env.CURSOR_API_KEY,
        githubToken: process.env.GITHUB_TOKEN,
        eslintConfig: require('./.eslintrc.js')
    });

    const pullNumber = process.env.GITHUB_PR_NUMBER;
    const [owner, repo] = process.env.GITHUB_REPOSITORY.split('/');
    
    const report = await bot.reviewPullRequest(owner, repo, pullNumber);
    
    // GitHub PR에 코멘트 작성
    await bot.github.issues.createComment({
        owner,
        repo,
        issue_number: pullNumber,
        body: formatReviewComment(report)
    });
    
    // 심각한 이슈가 있으면 PR 블록
    if (report.summary.criticalIssues > 0) {
        process.exit(1);
    }
}

function formatReviewComment(report) {
    return `## 🤖 AI 코드 리뷰 결과

### 📊 요약
- 검토한 파일: ${report.summary.totalFiles}개
- 발견된 이슈: ${report.summary.totalIssues}개
- 심각한 이슈: ${report.summary.criticalIssues}개
- 경고: ${report.summary.warnings}개
- 전체 점수: ${report.summary.overallScore}/100

### 📋 상세 리뷰
${report.fileReviews.map(formatFileReview).join('\n\n')}

### 💡 권장사항
${report.recommendations.map(formatRecommendation).join('\n')}
`;
}