MDC 성능 최적화: Cursor Rules의 효율성을 극대화하는 전문가 가이드

---

MDC 규칙이 많아질수록 Cursor의 응답 속도와 메모리 사용량에 영향을 줄 수 있습니다. 이 가이드에서는 규칙 로딩 속도 개선, 메모리 사용량 최적화, 컨텍스트 크기 관리 등 MDC의 성능을 극대화하는 실전 기법들을 상세히 다룹니다.

1. 규칙 로딩 속도 개선

효율적인 규칙 구조 설계

---
description: Optimized rule structure for fast loading
version: "1.0.0"
category: "performance"
loadingOptimized: true
tags: ["performance", "loading", "structure"]
---

# 고성능 규칙 구조 설계 원칙

## 규칙 크기 최적화

### 1. 규칙 분할 전략

잘못된 예: 거대한 단일 규칙
---
description: Complete development guidelines (5000+ lines)
alwaysApply: true
---
# 모든 개발 가이드라인을 하나의 파일에...
# - Frontend 패턴 (1000줄)
# - Backend API (1500줄)  
# - Database 설계 (1000줄)
# - DevOps 가이드 (1500줄)
# - 보안 체크리스트 (1000줄)

올바른 예: 모듈화된 규칙 구조
---
description: Core development principles
version: "1.0.0"
alwaysApply: true
size: "compact"
loadPriority: "high"
---

# 핵심 개발 원칙 (200줄 이내)

## 기본 원칙
- 코드 가독성 우선
- 단일 책임 원칙 적용
- 명시적 타입 정의

## 관련 규칙
특정 상황에서 다음 규칙들을 참조하세요:
- @frontend-patterns.mdc (Frontend 작업 시)
- @backend-api.mdc (API 개발 시)
- @database-design.mdc (DB 작업 시)

이 규칙은 빠른 로딩을 위해 핵심 사항만 포함합니다.

### 2. 지연 로딩 규칙 패턴
---
description: Lazy-loaded advanced patterns
version: "2.1.0"
alwaysApply: false
loadOnDemand: true
triggers: ["advanced", "optimization", "performance", "complex"]
estimatedLoadTime: "150ms"
---

# 고급 최적화 패턴 (지연 로딩)

## 트리거 조건
이 규칙은 다음 키워드가 언급될 때만 로드됩니다:
- "고급 최적화"
- "성능 튜닝" 
- "복잡한 패턴"
- "architecture optimization"

## 고급 성능 패턴

### 메모리 최적화
// 대용량 데이터 처리 시 스트리밍 사용
function processLargeDataset(data: Stream) {
  return data
    .pipe(transform(chunk => optimizeChunk(chunk)))
    .pipe(batch(1000))
    .pipe(process(batch => handleBatch(batch)));
}

// 메모리 누수 방지 패턴
class ResourceManager {
  private resources = new Map<string, Disposable>();
  
  acquire(id: string, resource: Disposable) {
    this.release(id); // 기존 리소스 정리
    this.resources.set(id, resource);
  }
  
  release(id: string) {
    const resource = this.resources.get(id);
    if (resource) {
      resource.dispose();
      this.resources.delete(id);
    }
  }
  
  cleanup() {
    for (const [id, resource] of this.resources) {
      resource.dispose();
    }
    this.resources.clear();
  }
}

### 비동기 최적화
// 병렬 처리 최적화
async function optimizedParallelProcessing<T>(
  items: T[],
  processor: (item: T) => Promise<any>,
  concurrency = 5
) {
  const semaphore = new Semaphore(concurrency);
  
  return await Promise.all(
    items.map(async (item) => {
      await semaphore.acquire();
      try {
        return await processor(item);
      } finally {
        semaphore.release();
      }
    })
  );
}

이 규칙은 고급 사용자를 위한 것으로, 필요시에만 로드됩니다.

@advanced-patterns/*.mdc
@performance-monitoring.ts

### 3. 규칙 로딩 우선순위 시스템
---
description: Rule loading priority system
version: "1.0.0"
category: "system"
---

# 규칙 로딩 우선순위 시스템

## 우선순위 레벨

### Level 1: Critical (즉시 로딩)
# 보안, 기본 코딩 표준 등 필수 규칙
loadPriority: 1
estimatedSize: "< 50KB"
maxLoadTime: "100ms"

### Level 2: Important (우선 로딩)  
# 프레임워크별 핵심 패턴
loadPriority: 2
estimatedSize: "< 200KB" 
maxLoadTime: "300ms"

### Level 3: Useful (필요시 로딩)
# 도메인 특화 규칙, 고급 패턴
loadPriority: 3
estimatedSize: "< 500KB"
maxLoadTime: "500ms"
loadOnDemand: true

### Level 4: Optional (지연 로딩)
# 참고 자료, 예제 코드
loadPriority: 4
estimatedSize: "무제한"
maxLoadTime: "1000ms"
loadOnDemand: true
triggers: ["specific-keywords"]

## 로딩 성능 모니터링
// 규칙 로딩 성능 추적
class RuleLoadingMonitor {
  private loadTimes = new Map<string, number>();
  
  startTracking(ruleId: string) {
    this.loadTimes.set(ruleId, performance.now());
  }
  
  endTracking(ruleId: string) {
    const startTime = this.loadTimes.get(ruleId);
    if (startTime) {
      const loadTime = performance.now() - startTime;
      console.log(`Rule ${ruleId} loaded in ${loadTime.toFixed(2)}ms`);
      
      // 성능 임계값 확인
      if (loadTime > 500) {
        console.warn(`Slow rule loading detected: ${ruleId}`);
      }
    }
  }
}

2. 메모리 사용량 최적화

불필요한 규칙 제거 및 최적화

---
description: Memory optimization strategies for MDC rules
version: "1.5.0"
category: "optimization"
memoryOptimized: true
---

# 메모리 사용량 최적화 전략

## 규칙 정리 체계

### 1. 사용되지 않는 규칙 탐지
#!/bin/bash
# scripts/detect-unused-rules.sh

echo "🔍 사용되지 않는 규칙 탐지 중..."

# 최근 30일간 적용되지 않은 규칙 찾기
find .cursor/rules -name "*.mdc" -type f | while read rule; do
  rule_name=$(basename "$rule" .mdc)
  
  # Git 로그에서 규칙 참조 확인
  if ! git log --since="30 days ago" --grep="$rule_name" --oneline | grep -q .; then
    # 코드에서 직접 참조 확인
    if ! grep -r "@$rule_name" src/ --include="*.ts" --include="*.tsx" --include="*.js" --include="*.jsx" > /dev/null; then
      echo "⚠️  미사용 규칙 발견: $rule"
      
      # 규칙 크기 확인
      size=$(wc -c < "$rule")
      echo "   크기: ${size} bytes"
    fi
  fi
done

### 2. 규칙 압축 및 최적화

압축 전 (verbose)
---
description: Detailed React component development guidelines with extensive examples and explanations
version: "1.0.0"
alwaysApply: false
category: "frontend"
framework: "react"
maintainer: "Frontend Team"
lastReviewed: "2024-01-15"
reviewCycle: "quarterly"
relatedRules: ["typescript-standards.mdc", "testing-patterns.mdc"]
---

# React 컴포넌트 개발 가이드라인

## 상세한 설명
React 컴포넌트를 개발할 때는 다양한 측면을 고려해야 합니다. 
성능, 재사용성, 테스트 가능성, 접근성 등을 모두 고려하여...
(장황한 설명 계속...)

## 예제 코드
// 매우 상세한 예제 코드 (100줄+)
interface VeryDetailedProps {
  // 모든 가능한 props 나열...
}
// ... 더 많은 예제

압축 후 (optimized)
---
description: React component patterns
version: "1.0.0"
globs: ["src/components/**/*.{ts,tsx}"]
alwaysApply: false
compressed: true
---

# React 컴포넌트 패턴

## 핵심 원칙
- 함수형 컴포넌트 + TypeScript
- Props 인터페이스 명확히 정의
- 적절한 메모이제이션 적용

## 기본 템플릿
interface Props {
  // 필수 props만
}

export const Component: FC<Props> = ({ prop }) => {
  // 최소 구현
};

## 상세 가이드
세부사항은 @react-detailed-guide.mdc 참조 (온디맨드 로딩)

@component-template.tsx

### 3. 메모리 사용량 모니터링
// utils/memory-monitor.ts
class MemoryMonitor {
  private ruleMemoryUsage = new Map<string, number>();
  
  trackRuleLoading(ruleId: string, content: string) {
    // 규칙 메모리 사용량 계산 (대략적)
    const memoryUsage = new Blob([content]).size;
    this.ruleMemoryUsage.set(ruleId, memoryUsage);
    
    this.checkMemoryThreshold();
  }
  
  private checkMemoryThreshold() {
    const totalMemory = Array.from(this.ruleMemoryUsage.values())
      .reduce((sum, usage) => sum + usage, 0);
    
    const MEMORY_THRESHOLD = 10 * 1024 * 1024; // 10MB
    
    if (totalMemory > MEMORY_THRESHOLD) {
      console.warn('⚠️ 규칙 메모리 사용량이 임계값을 초과했습니다:', {
        total: `${(totalMemory / 1024 / 1024).toFixed(2)}MB`,
        threshold: `${(MEMORY_THRESHOLD / 1024 / 1024).toFixed(2)}MB`,
        topRules: this.getTopMemoryConsumers(5)
      });
      
      // 자동 정리 제안
      this.suggestOptimizations();
    }
  }
  
  private getTopMemoryConsumers(count: number) {
    return Array.from(this.ruleMemoryUsage.entries())
      .sort(([,a], [,b]) => b - a)
      .slice(0, count)
      .map(([rule, memory]) => ({
        rule,
        memory: `${(memory / 1024).toFixed(2)}KB`
      }));
  }
  
  private suggestOptimizations() {
    const suggestions = [
      '🔧 큰 규칙을 여러 개의 작은 규칙으로 분할하기',
      '📦 자주 사용되지 않는 규칙에 지연 로딩 적용',
      '🗑️ 사용되지 않는 규칙 제거',
      '📝 규칙 내용 압축 및 간소화'
    ];
    
    console.log('💡 최적화 제안:', suggestions);
  }
}

3. 컨텍스트 크기 관리

토큰 제한 내에서 최대 효과 얻기

---
description: Context size management and token optimization
version: "2.0.0"
category: "optimization"
contextOptimized: true
---

# 컨텍스트 크기 관리 전략

## 토큰 효율성 최적화

### 1. 스마트 컨텍스트 선택
contextSelectionStrategy: "priority-based"
maxTokens: 8000
tokenBuffer: 500  # 응답을 위한 여유 공간

우선순위 기반 규칙 로딩:
1. Critical (보안, 필수 패턴): 항상 포함
2. Relevant (현재 작업과 관련): 파일 타입별 선택
3. Helpful (추가 도움): 토큰 여유 있을 때만
4. Reference (참고 자료): 명시적 요청 시에만

### 2. 동적 컨텍스트 조정
// context-manager.ts
interface ContextRule {
  id: string;
  content: string;
  priority: number;
  tokenCount: number;
  relevanceScore: number;
}

class ContextManager {
  private readonly MAX_TOKENS = 8000;
  private readonly RESPONSE_BUFFER = 1000;
  
  selectOptimalRules(
    availableRules: ContextRule[],
    currentContext: string
  ): ContextRule[] {
    const maxContextTokens = this.MAX_TOKENS - this.RESPONSE_BUFFER;
    const currentContextTokens = this.countTokens(currentContext);
    const availableTokens = maxContextTokens - currentContextTokens;
    
    // 우선순위와 관련성 점수로 정렬
    const sortedRules = availableRules.sort((a, b) => {
      const scoreA = (a.priority * 0.6) + (a.relevanceScore * 0.4);
      const scoreB = (b.priority * 0.6) + (b.relevanceScore * 0.4);
      return scoreB - scoreA;
    });
    
    const selectedRules: ContextRule[] = [];
    let usedTokens = 0;
    
    for (const rule of sortedRules) {
      if (usedTokens + rule.tokenCount <= availableTokens) {
        selectedRules.push(rule);
        usedTokens += rule.tokenCount;
      } else {
        // 토큰 부족 시 규칙 압축 시도
        const compressedRule = this.compressRule(rule, availableTokens - usedTokens);
        if (compressedRule) {
          selectedRules.push(compressedRule);
          break;
        }
      }
    }
    
    console.log(`📊 컨텍스트 통계:`, {
      selectedRules: selectedRules.length,
      totalRules: availableRules.length,
      usedTokens,
      availableTokens,
      efficiency: `${((usedTokens / availableTokens) * 100).toFixed(1)}%`
    });
    
    return selectedRules;
  }
  
  private compressRule(rule: ContextRule, maxTokens: number): ContextRule | null {
    // 규칙 압축 로직
    const lines = rule.content.split('\n');
    const essential = lines.filter(line => 
      line.includes('✅') || 
      line.includes('❌') || 
      line.startsWith('##') ||
      line.includes('@')
    );
    
    const compressedContent = essential.join('\n');
    const tokenCount = this.countTokens(compressedContent);
    
    if (tokenCount <= maxTokens) {
      return {
        ...rule,
        content: compressedContent,
        tokenCount
      };
    }
    
    return null;
  }
  
  private countTokens(text: string): number {
    // 대략적인 토큰 계산 (실제로는 더 정확한 토크나이저 사용)
    return Math.ceil(text.length / 4);
  }
}

### 3. 관련성 기반 필터링
// relevance-calculator.ts
class RelevanceCalculator {
  calculateRelevance(rule: ContextRule, context: {
    currentFile: string;
    projectType: string;
    recentFiles: string[];
    userQuery: string;
  }): number {
    let score = 0;
    
    // 파일 타입 매칭 (40% 가중치)
    if (this.matchesFileType(rule, context.currentFile)) {
      score += 0.4;
    }
    
    // 프로젝트 타입 매칭 (30% 가중치)  
    if (this.matchesProjectType(rule, context.projectType)) {
      score += 0.3;
    }
    
    // 사용자 쿼리 관련성 (20% 가중치)
    const queryRelevance = this.calculateQueryRelevance(rule, context.userQuery);
    score += queryRelevance * 0.2;
    
    // 최근 사용 빈도 (10% 가중치)
    const usageFrequency = this.calculateUsageFrequency(rule, context.recentFiles);
    score += usageFrequency * 0.1;
    
    return Math.min(score, 1.0);
  }
  
  private matchesFileType(rule: ContextRule, filePath: string): boolean {
    const ext = filePath.split('.').pop()?.toLowerCase();
    const ruleGlobs = this.extractGlobs(rule.content);
    
    return ruleGlobs.some(glob => 
      glob.includes(`.${ext}`) || 
      glob.includes(`**/*.${ext}`)
    );
  }
  
  private calculateQueryRelevance(rule: ContextRule, query: string): number {
    const queryWords = query.toLowerCase().split(/\s+/);
    const ruleContent = rule.content.toLowerCase();
    
    const matchCount = queryWords.filter(word => 
      ruleContent.includes(word)
    ).length;
    
    return queryWords.length > 0 ? matchCount / queryWords.length : 0;
  }
  
  private extractGlobs(content: string): string[] {
    const globMatch = content.match(/globs:\s*\[(.*?)\]/s);
    if (!globMatch) return [];
    
    try {
      return JSON.parse(`[${globMatch[1]}]`);
    } catch {
      return [];
    }
  }
}

4. 실시간 성능 모니터링

성능 메트릭 수집 및 분석

---
description: Real-time performance monitoring for MDC rules
version: "1.3.0"
category: "monitoring"
---

# 실시간 성능 모니터링 시스템

## 주요 성능 지표

### 1. 응답 시간 모니터링
// performance-tracker.ts
interface PerformanceMetrics {
  ruleLoadTime: number;
  contextBuildTime: number;
  aiResponseTime: number;
  totalTime: number;
  memoryUsage: number;
  activeRules: number;
}

class PerformanceTracker {
  private metrics: PerformanceMetrics[] = [];
  private readonly MAX_HISTORY = 100;
  
  startRequest(): string {
    const requestId = `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
    const startTime = performance.now();
    
    // 메모리 사용량 측정
    const memoryUsage = (performance as any).memory?.usedJSHeapSize || 0;
    
    this.recordMetric(requestId, {
      startTime,
      memoryUsage
    });
    
    return requestId;
  }
  
  recordRuleLoading(requestId: string, loadTime: number, ruleCount: number) {
    this.updateMetric(requestId, {
      ruleLoadTime: loadTime,
      activeRules: ruleCount
    });
  }
  
  recordContextBuilding(requestId: string, buildTime: number) {
    this.updateMetric(requestId, {
      contextBuildTime: buildTime
    });
  }
  
  endRequest(requestId: string, aiResponseTime: number) {
    const metric = this.getMetric(requestId);
    if (metric) {
      const totalTime = performance.now() - metric.startTime;
      
      this.updateMetric(requestId, {
        aiResponseTime,
        totalTime
      });
      
      this.analyzePerformance(requestId);
    }
  }
  
  private analyzePerformance(requestId: string) {
    const metric = this.getMetric(requestId);
    if (!metric) return;
    
    const analysis = {
      isOptimal: metric.totalTime < 2000, // 2초 이내
      bottlenecks: this.identifyBottlenecks(metric),
      suggestions: this.generateSuggestions(metric)
    };
    
    if (!analysis.isOptimal) {
      console.warn('🐌 성능 이슈 감지:', {
        requestId,
        totalTime: `${metric.totalTime.toFixed(2)}ms`,
        bottlenecks: analysis.bottlenecks,
        suggestions: analysis.suggestions
      });
    }
    
    // 히스토리 유지
    this.metrics.push(metric);
    if (this.metrics.length > this.MAX_HISTORY) {
      this.metrics.shift();
    }
  }
  
  private identifyBottlenecks(metric: PerformanceMetrics): string[] {
    const bottlenecks: string[] = [];
    
    if (metric.ruleLoadTime > 500) {
      bottlenecks.push('규칙 로딩 속도');
    }
    
    if (metric.contextBuildTime > 300) {
      bottlenecks.push('컨텍스트 구성');
    }
    
    if (metric.aiResponseTime > 3000) {
      bottlenecks.push('AI 응답 시간');
    }
    
    if (metric.memoryUsage > 50 * 1024 * 1024) { // 50MB
      bottlenecks.push('메모리 사용량');
    }
    
    return bottlenecks;
  }
  
  private generateSuggestions(metric: PerformanceMetrics): string[] {
    const suggestions: string[] = [];
    
    if (metric.ruleLoadTime > 500) {
      suggestions.push('큰 규칙을 여러 개로 분할하거나 지연 로딩 적용');
    }
    
    if (metric.activeRules > 20) {
      suggestions.push('활성 규칙 수를 줄이거나 우선순위 기반 선택 적용');
    }
    
    if (metric.contextBuildTime > 300) {
      suggestions.push('컨텐스트 크기를 줄이거나 압축 알고리즘 적용');
    }
    
    return suggestions;
  }
  
  generateReport(): PerformanceReport {
    const recent = this.metrics.slice(-20); // 최근 20개 요청
    
    return {
      averageResponseTime: this.average(recent.map(m => m.totalTime)),
      averageRuleLoadTime: this.average(recent.map(m => m.ruleLoadTime)),
      averageMemoryUsage: this.average(recent.map(m => m.memoryUsage)),
      slowRequests: recent.filter(m => m.totalTime > 3000).length,
      recommendations: this.generateRecommendations(recent)
    };
  }
  
  private generateRecommendations(metrics: PerformanceMetrics[]): string[] {
    const recommendations: string[] = [];
    
    const avgLoadTime = this.average(metrics.map(m => m.ruleLoadTime));
    if (avgLoadTime > 400) {
      recommendations.push('전체적인 규칙 최적화 필요');
    }
    
    const avgActiveRules = this.average(metrics.map(m => m.activeRules));
    if (avgActiveRules > 15) {
      recommendations.push('규칙 선택 알고리즘 개선 필요');
    }
    
    return recommendations;
  }
  
  private average(numbers: number[]): number {
    return numbers.reduce((sum, n) => sum + n, 0) / numbers.length;
  }
}

### 2. 자동 최적화 시스템
// auto-optimizer.ts
class AutoOptimizer {
  private performanceTracker: PerformanceTracker;
  private optimizationHistory: OptimizationAction[] = [];
  
  constructor(tracker: PerformanceTracker) {
    this.performanceTracker = tracker;
    this.startMonitoring();
  }
  
  private startMonitoring() {
    setInterval(() => {
      this.analyzeAndOptimize();
    }, 60000); // 1분마다 분석
  }
  
  private async analyzeAndOptimize() {
    const report = this.performanceTracker.generateReport();
    
    // 성능 임계값 확인
    if (report.averageResponseTime > 3000) {
      await this.applyOptimizations(report);
    }
  }
  
  private async applyOptimizations(report: PerformanceReport) {
    const actions: OptimizationAction[] = [];
    
    // 규칙 압축
    if (report.averageRuleLoadTime > 500) {
      actions.push({
        type: 'compress-rules',
        target: 'large-rules',
        expectedImprovement: '30% 로딩 시간 단축'
      });
    }
    
    // 지연 로딩 적용
    if (report.averageMemoryUsage > 30 * 1024 * 1024) {
      actions.push({
        type: 'apply-lazy-loading',
        target: 'rarely-used-rules',
        expectedImprovement: '40% 메모리 절약'
      });
    }
    
    // 캐싱 개선
    if (report.slowRequests > 5) {
      actions.push({
        type: 'improve-caching',
        target: 'frequent-rules',
        expectedImprovement: '50% 응답 시간 개선'
      });
    }
    
    // 최적화 실행
    for (const action of actions) {
      await this.executeOptimization(action);
      this.optimizationHistory.push({
        ...action,
        timestamp: new Date(),
        status: 'applied'
      });
    }
    
    if (actions.length > 0) {
      console.log('🔧 자동 최적화 적용됨:', actions);
    }
  }
  
  private async executeOptimization(action: OptimizationAction) {
    switch (action.type) {
      case 'compress-rules':
        await this.compressLargeRules();
        break;
      case 'apply-lazy-loading':
        await this.enableLazyLoading();
        break;
      case 'improve-caching':
        await this.optimizeCaching();
        break;
    }
  }
  
  private async compressLargeRules() {
    // 큰 규칙들을 찾아서 압축
    const largeRules = await this.findLargeRules();
    
    for (const rule of largeRules) {
      const compressed = await this.compressRule(rule);
      await this.saveCompressedRule(rule.id, compressed);
    }
  }
  
  private async enableLazyLoading() {
    // 자주 사용되지 않는 규칙에 지연 로딩 적용
    const rarelyUsedRules = await this.findRarelyUsedRules();
    
    for (const rule of rarelyUsedRules) {
      await this.addLazyLoadingFlag(rule.id);
    }
  }
  
  private async optimizeCaching() {
    // 자주 사용되는 규칙의 캐싱 개선
    const frequentRules = await this.findFrequentRules();
    
    for (const rule of frequentRules) {
      await this.improveRuleCaching(rule.id);
    }
  }
}

5. 성능 벤치마크 및 최적화 검증

성능 테스트 자동화

---
description: Performance benchmarking and optimization validation
version: "1.0.0"
category: "testing"
---

# 성능 벤치마크 시스템

## 벤치마크 테스트 스위트

### 1. 로딩 성능 테스트
// benchmarks/loading-performance.test.ts
describe('Rule Loading Performance', () => {
  let performanceTracker: PerformanceTracker;
  
  beforeEach(() => {
    performanceTracker = new PerformanceTracker();
  });
  
  test('should load core rules within 200ms', async () => {
    const startTime = performance.now();
    
    await loadCoreRules();
    
    const loadTime = performance.now() - startTime;
    expect(loadTime).toBeLessThan(200);
  });
  
  test('should load framework-specific rules within 300ms', async () => {
    const frameworks = ['react', 'vue', 'angular', 'svelte'];
    
    for (const framework of frameworks) {
      const startTime = performance.now();
      
      await loadFrameworkRules(framework);
      
      const loadTime = performance.now() - startTime;
      expect(loadTime).toBeLessThan(300);
    }
  });
  
  test('should handle concurrent rule loading efficiently', async () => {
    const concurrentLoads = 10;
    const promises = Array(concurrentLoads).fill(0).map(() => 
      loadRandomRuleSet()
    );
    
    const startTime = performance.now();
    await Promise.all(promises);
    const totalTime = performance.now() - startTime;
    
    // 동시 로딩이 순차 로딩보다 효율적이어야 함
    expect(totalTime).toBeLessThan(concurrentLoads * 100);
  });
});

describe('Memory Usage Tests', () => {
  test('should maintain memory usage under threshold', async () => {
    const initialMemory = process.memoryUsage().heapUsed;
    
    // 대량의 규칙 로딩
    await loadLargeRuleSet();
    
    const currentMemory = process.memoryUsage().heapUsed;
    const memoryIncrease = currentMemory - initialMemory;
    
    // 메모리 증가량이 20MB를 초과하지 않아야 함
    expect(memoryIncrease).toBeLessThan(20 * 1024 * 1024);
  });
  
  test('should properly cleanup unused rules', async () => {
    await loadTemporaryRules();
    
    const beforeCleanup = process.memoryUsage().heapUsed;
    
    await cleanupUnusedRules();
    
    // 강제 가비지 컬렉션
    global.gc && global.gc();
    
    const afterCleanup = process.memoryUsage().heapUsed;
    
    // 메모리가 정리되어야 함
    expect(afterCleanup).toBeLessThan(beforeCleanup);
  });
});

### 2. 성능 회귀 테스트
// benchmarks/regression-tests.ts
class PerformanceRegressionTester {
  private baselineMetrics: PerformanceBaseline;
  
  constructor(baselinePath: string) {
    this.baselineMetrics = this.loadBaseline(baselinePath);
  }
  
  async runRegressionTests(): Promise<RegressionReport> {
    const currentMetrics = await this.measureCurrentPerformance();
    const comparison = this.compareMetrics(this.baselineMetrics, currentMetrics);
    
    return {
      passed: comparison.regressions.length === 0,
      improvements: comparison.improvements,
      regressions: comparison.regressions,
      recommendations: this.generateRecommendations(comparison)
    };
  }
  
  private async measureCurrentPerformance(): Promise<PerformanceMetrics> {
    const metrics: PerformanceMetrics = {
      ruleLoadTime: [],
      memoryUsage: [],
      contextBuildTime: [],
      responseTime: []
    };
    
    // 여러 번 측정하여 평균값 계산
    for (let i = 0; i < 10; i++) {
      const measurement = await this.singleMeasurement();
      metrics.ruleLoadTime.push(measurement.ruleLoadTime);
      metrics.memoryUsage.push(measurement.memoryUsage);
      metrics.contextBuildTime.push(measurement.contextBuildTime);
      metrics.responseTime.push(measurement.responseTime);
    }
    
    return {
      ruleLoadTime: this.average(metrics.ruleLoadTime),
      memoryUsage: this.average(metrics.memoryUsage),
      contextBuildTime: this.average(metrics.contextBuildTime),
      responseTime: this.average(metrics.responseTime)
    };
  }
  
  private compareMetrics(baseline: PerformanceBaseline, current: PerformanceMetrics): Comparison {
    const threshold = 0.1; // 10% 성능 저하까지 허용
    
    const improvements: string[] = [];
    const regressions: string[] = [];
    
    // 각 메트릭 비교
    Object.keys(baseline).forEach(key => {
      const baseValue = baseline[key];
      const currentValue = current[key];
      const change = (currentValue - baseValue) / baseValue;
      
      if (change > threshold) {
        regressions.push(`${key}: ${(change * 100).toFixed(1)}% 성능 저하`);
      } else if (change < -0.05) { // 5% 이상 개선
        improvements.push(`${key}: ${Math.abs(change * 100).toFixed(1)}% 성능 개선`);
      }
    });
    
    return { improvements, regressions };
  }
  
  updateBaseline(newBaseline: PerformanceMetrics) {
    this.baselineMetrics = newBaseline;
    this.saveBaseline('benchmarks/baseline.json', newBaseline);
  }
}

### 3. 지속적 성능 모니터링
#!/bin/bash
# scripts/performance-ci.sh

echo "🚀 성능 테스트 시작..."

# 성능 테스트 실행
npm run test:performance

# 회귀 테스트 실행
npm run test:regression

# 벤치마크 결과 분석
node scripts/analyze-benchmarks.js

# 성능 리포트 생성
node scripts/generate-performance-report.js

echo "📊 성능 테스트 완료"

// scripts/analyze-benchmarks.js
const fs = require('fs');
const path = require('path');

function analyzeBenchmarks() {
  const benchmarkResults = JSON.parse(
    fs.readFileSync('benchmarks/latest-results.json', 'utf8')
  );
  
  const analysis = {
    summary: generateSummary(benchmarkResults),
    trends: analyzeTrends(benchmarkResults),
    recommendations: generateRecommendations(benchmarkResults)
  };
  
  // 성능 이슈 감지
  if (analysis.summary.criticalIssues > 0) {
    console.error('❌ 심각한 성능 이슈 감지됨');
    process.exit(1);
  }
  
  // 보고서 저장
  fs.writeFileSync(
    'benchmarks/analysis-report.json',
    JSON.stringify(analysis, null, 2)
  );
  
  console.log('✅ 성능 분석 완료');
}

analyzeBenchmarks();
``` analyzeBenchmarks() {
  const benchmarkResults = JSON.parse(
    fs.readFileSync('benchmarks/latest-results.json', 'utf8')
  );
  
  const analysis = {
    summary: generateSummary(benchmarkResults),
    trends: analyzeTrends(benchmarkResults),
    recommendations: generateRecommendations(benchmarkResults)
  };
  
  // 성능 이슈 감지
  if (analysis.summary.criticalIssues > 0) {
    console.error('❌ 심각한 성능 이슈 감지됨');
    process.exit(1);
  }
  
  // 보고서 저장
  fs.writeFileSync(
    'benchmarks/analysis-report.json',
    JSON.stringify(analysis, null, 2)
  );
  
  console.log('✅ 성능 분석 완료');
}

analyzeBenchmarks();

최적화 체크리스트

## ?? MDC 성능 최적화 체크리스트

### 규칙 구조 최적화
- [ ] 규칙 크기 500줄 이하 유지
- [ ] 큰 규칙을 여러 개로 분할
- [ ] 지연 로딩 적절히 적용
- [ ] 불필요한 규칙 제거

### 메모리 관리
- [ ] 메모리 사용량 모니터링 설정
- [ ] 사용되지 않는 규칙 정기 정리  
- [ ] 규칙 압축 적용
- [ ] 메모리 누수 방지

### 컨텍스트 최적화
- [ ] 토큰 제한 내 효율적 사용
- [ ] 우선순위 기반 규칙 선택
- [ ] 관련성 기반 필터링
- [ ] 동적 컨텍스트 조정

### 성능 모니터링
- [ ] 응답 시간 추적
- [ ] 자동 최적화 시스템 구축
- [ ] 성능 회귀 테스트 자동화
- [ ] 지속적 성능 개선

### 배포 최적화
- [ ] 프로덕션 환경 최적화 설정
- [ ] 캐싱 전략 구현
- [ ] CDN 활용 (규칙 저장소)
- [ ] 로드 밸런싱 고려

이러한 성능 최적화 기법들을 적용하면 MDC 규칙의 로딩 속도를 개선하고, 메모리 사용량을 최적화하며, 전반적인 Cursor 사용 경험을 크게 향상시킬 수 있습니다. 프로젝트 규모와 팀 요구사항에 맞게 적절한 최적화 전략을 선택하여 적용해보시기 바랍니다.

---