aiwf 0.3.7 → 0.3.8

package/src/lib/resources/utils/compression-metrics.js

@@ -0,0 +1,1031 @@
+import { TokenCounter } from './token-counter.js';
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * 압축률 측정 및 성능 분석 도구
+ */
+export class CompressionMetrics {
+  constructor() {
+    this.tokenCounter = new TokenCounter();
+    this.measurements = new Map();
+    this.benchmarks = new Map();
+    this.initializeMetrics();
+  }
+
+  /**
+   * 메트릭 시스템을 초기화합니다
+   */
+  initializeMetrics() {
+    // 메트릭 타입 정의
+    this.metricTypes = {
+      compression: {
+        name: 'Compression Metrics',
+        description: '압축률 관련 메트릭',
+        measurements: [
+          'compression_ratio',
+          'token_reduction',
+          'size_reduction',
+          'information_preservation'
+        ]
+      },
+      performance: {
+        name: 'Performance Metrics',
+        description: '성능 관련 메트릭',
+        measurements: [
+          'compression_time',
+          'decompression_time',
+          'memory_usage',
+          'throughput'
+        ]
+      },
+      quality: {
+        name: 'Quality Metrics',
+        description: '품질 관련 메트릭',
+        measurements: [
+          'readability_score',
+          'structure_preservation',
+          'semantic_similarity',
+          'information_loss'
+        ]
+      },
+      efficiency: {
+        name: 'Efficiency Metrics',
+        description: '효율성 관련 메트릭',
+        measurements: [
+          'tokens_per_second',
+          'compression_efficiency',
+          'resource_utilization',
+          'cost_effectiveness'
+        ]
+      }
+    };
+
+    // 벤치마크 기준점
+    this.benchmarkThresholds = {
+      compression_ratio: {
+        excellent: 70,
+        good: 50,
+        acceptable: 30,
+        poor: 10
+      },
+      compression_time: {
+        excellent: 1000,   // 1초
+        good: 3000,        // 3초
+        acceptable: 5000,  // 5초
+        poor: 10000        // 10초
+      },
+      information_preservation: {
+        excellent: 90,
+        good: 80,
+        acceptable: 70,
+        poor: 50
+      },
+      readability_score: {
+        excellent: 90,
+        good: 80,
+        acceptable: 70,
+        poor: 50
+      }
+    };
+
+    // 측정 히스토리
+    this.measurementHistory = [];
+  }
+
+  /**
+   * 압축 결과를 측정합니다
+   * @param {string} original - 원본 콘텐츠
+   * @param {string} compressed - 압축된 콘텐츠
+   * @param {Object} metadata - 압축 메타데이터
+   * @returns {Object} 측정 결과
+   */
+  measureCompression(original, compressed, metadata = {}) {
+    const measurementId = this.generateMeasurementId();
+    const timestamp = Date.now();
+    
+    const measurement = {
+      id: measurementId,
+      timestamp,
+      originalContent: original,
+      compressedContent: compressed,
+      metadata,
+      metrics: {},
+      analysis: {},
+      benchmark: {}
+    };
+
+    // 1. 압축 메트릭 계산
+    measurement.metrics.compression = this.calculateCompressionMetrics(original, compressed);
+
+    // 2. 성능 메트릭 계산
+    measurement.metrics.performance = this.calculatePerformanceMetrics(metadata);
+
+    // 3. 품질 메트릭 계산
+    measurement.metrics.quality = this.calculateQualityMetrics(original, compressed, metadata);
+
+    // 4. 효율성 메트릭 계산
+    measurement.metrics.efficiency = this.calculateEfficiencyMetrics(original, compressed, metadata);
+
+    // 5. 벤치마크 분석
+    measurement.benchmark = this.analyzeBenchmark(measurement.metrics);
+
+    // 6. 종합 분석
+    measurement.analysis = this.generateAnalysis(measurement.metrics, measurement.benchmark);
+
+    // 측정 결과 저장
+    this.measurements.set(measurementId, measurement);
+    this.measurementHistory.push(measurement);
+
+    return measurement;
+  }
+
+  /**
+   * 압축 메트릭을 계산합니다
+   * @param {string} original - 원본 콘텐츠
+   * @param {string} compressed - 압축된 콘텐츠
+   * @returns {Object} 압축 메트릭
+   */
+  calculateCompressionMetrics(original, compressed) {
+    const originalTokens = this.tokenCounter.countTokens(original);
+    const compressedTokens = this.tokenCounter.countTokens(compressed);
+    const originalSize = Buffer.byteLength(original, 'utf8');
+    const compressedSize = Buffer.byteLength(compressed, 'utf8');
+
+    const tokenReduction = originalTokens - compressedTokens;
+    const sizeReduction = originalSize - compressedSize;
+    const compressionRatio = originalTokens > 0 ? (tokenReduction / originalTokens) * 100 : 0;
+    const sizeCompressionRatio = originalSize > 0 ? (sizeReduction / originalSize) * 100 : 0;
+
+    // 정보 보존률 계산
+    const informationPreservation = this.calculateInformationPreservation(original, compressed);
+
+    return {
+      original_tokens: originalTokens,
+      compressed_tokens: compressedTokens,
+      token_reduction: tokenReduction,
+      token_reduction_percentage: compressionRatio,
+      original_size: originalSize,
+      compressed_size: compressedSize,
+      size_reduction: sizeReduction,
+      size_reduction_percentage: sizeCompressionRatio,
+      information_preservation: informationPreservation,
+      compression_efficiency: this.calculateCompressionEfficiency(compressionRatio, informationPreservation)
+    };
+  }
+
+  /**
+   * 성능 메트릭을 계산합니다
+   * @param {Object} metadata - 메타데이터
+   * @returns {Object} 성능 메트릭
+   */
+  calculatePerformanceMetrics(metadata) {
+    const performance = {
+      compression_time: metadata.processingTime || 0,
+      decompression_time: metadata.decompressionTime || 0,
+      memory_usage: metadata.memoryUsage || 0,
+      throughput: 0,
+      tokens_per_second: 0
+    };
+
+    // 처리량 계산
+    if (performance.compression_time > 0 && metadata.originalTokens) {
+      performance.tokens_per_second = (metadata.originalTokens / performance.compression_time) * 1000;
+      performance.throughput = (metadata.originalTokens / performance.compression_time) * 1000;
+    }
+
+    // 메모리 효율성 계산
+    if (performance.memory_usage > 0 && metadata.originalTokens) {
+      performance.memory_efficiency = metadata.originalTokens / performance.memory_usage;
+    }
+
+    // 파이프라인 성능 분석
+    if (metadata.pipelineStages) {
+      performance.pipeline_analysis = this.analyzePipelinePerformance(metadata.pipelineStages);
+    }
+
+    return performance;
+  }
+
+  /**
+   * 품질 메트릭을 계산합니다
+   * @param {string} original - 원본 콘텐츠
+   * @param {string} compressed - 압축된 콘텐츠
+   * @param {Object} metadata - 메타데이터
+   * @returns {Object} 품질 메트릭
+   */
+  calculateQualityMetrics(original, compressed, metadata) {
+    const quality = {
+      readability_score: this.calculateReadabilityScore(compressed),
+      structure_preservation: this.calculateStructurePreservation(original, compressed),
+      semantic_similarity: this.calculateSemanticSimilarity(original, compressed),
+      information_loss: this.calculateInformationLoss(original, compressed),
+      coherence_score: this.calculateCoherenceScore(compressed),
+      completeness_score: this.calculateCompletenessScore(original, compressed)
+    };
+
+    // 전체 품질 점수 계산
+    quality.overall_quality = this.calculateOverallQuality(quality);
+
+    return quality;
+  }
+
+  /**
+   * 효율성 메트릭을 계산합니다
+   * @param {string} original - 원본 콘텐츠
+   * @param {string} compressed - 압축된 콘텐츠
+   * @param {Object} metadata - 메타데이터
+   * @returns {Object} 효율성 메트릭
+   */
+  calculateEfficiencyMetrics(original, compressed, metadata) {
+    const originalTokens = this.tokenCounter.countTokens(original);
+    const compressedTokens = this.tokenCounter.countTokens(compressed);
+    const processingTime = metadata.processingTime || 1;
+
+    const efficiency = {
+      compression_efficiency: this.calculateCompressionEfficiency(
+        ((originalTokens - compressedTokens) / originalTokens) * 100,
+        this.calculateInformationPreservation(original, compressed)
+      ),
+      resource_utilization: this.calculateResourceUtilization(metadata),
+      cost_effectiveness: this.calculateCostEffectiveness(originalTokens, compressedTokens, processingTime),
+      energy_efficiency: this.calculateEnergyEfficiency(originalTokens, processingTime)
+    };
+
+    return efficiency;
+  }
+
+  /**
+   * 정보 보존률을 계산합니다
+   * @param {string} original - 원본 콘텐츠
+   * @param {string} compressed - 압축된 콘텐츠
+   * @returns {number} 정보 보존률 (0-100)
+   */
+  calculateInformationPreservation(original, compressed) {
+    // 키워드 보존률 계산
+    const originalKeywords = this.extractKeywords(original);
+    const compressedKeywords = this.extractKeywords(compressed);
+    
+    const preservedKeywords = originalKeywords.filter(keyword => 
+      compressedKeywords.includes(keyword)
+    );
+    
+    const keywordPreservation = originalKeywords.length > 0 
+      ? (preservedKeywords.length / originalKeywords.length) * 100 
+      : 100;
+
+    // 구조 보존률 계산
+    const structurePreservation = this.calculateStructurePreservation(original, compressed);
+
+    // 의미 보존률 계산
+    const semanticPreservation = this.calculateSemanticSimilarity(original, compressed);
+
+    // 가중 평균 계산
+    return (keywordPreservation * 0.4 + structurePreservation * 0.3 + semanticPreservation * 0.3);
+  }
+
+  /**
+   * 키워드를 추출합니다
+   * @param {string} text - 텍스트
+   * @returns {Array<string>} 키워드 배열
+   */
+  extractKeywords(text) {
+    const keywords = [];
+    const words = text.toLowerCase().split(/\s+/);
+    
+    // 중요한 키워드 패턴
+    const keywordPatterns = [
+      /\b(goal|objective|task|requirement|critical|important|key|main|primary|essential)\b/g,
+      /\b(목표|목적|태스크|요구사항|중요|핵심|주요|필수|기본|우선)\b/g
+    ];
+
+    for (const pattern of keywordPatterns) {
+      const matches = text.match(pattern);
+      if (matches) {
+        keywords.push(...matches);
+      }
+    }
+
+    // 고유 키워드만 반환
+    return [...new Set(keywords)];
+  }
+
+  /**
+   * 구조 보존률을 계산합니다
+   * @param {string} original - 원본 콘텐츠
+   * @param {string} compressed - 압축된 콘텐츠
+   * @returns {number} 구조 보존률 (0-100)
+   */
+  calculateStructurePreservation(original, compressed) {
+    const originalHeaders = (original.match(/^#{1,6}\s+.+$/gm) || []).length;
+    const compressedHeaders = (compressed.match(/^#{1,6}\s+.+$/gm) || []).length;
+    
+    const originalLists = (original.match(/^\s*[-*+]\s+/gm) || []).length;
+    const compressedLists = (compressed.match(/^\s*[-*+]\s+/gm) || []).length;
+    
+    const originalCodeBlocks = (original.match(/```[\s\S]*?```/g) || []).length;
+    const compressedCodeBlocks = (compressed.match(/```[\s\S]*?```/g) || []).length;
+
+    const headerPreservation = originalHeaders > 0 ? (compressedHeaders / originalHeaders) * 100 : 100;
+    const listPreservation = originalLists > 0 ? (compressedLists / originalLists) * 100 : 100;
+    const codePreservation = originalCodeBlocks > 0 ? (compressedCodeBlocks / originalCodeBlocks) * 100 : 100;
+
+    return (headerPreservation + listPreservation + codePreservation) / 3;
+  }
+
+  /**
+   * 의미 유사도를 계산합니다
+   * @param {string} original - 원본 콘텐츠
+   * @param {string} compressed - 압축된 콘텐츠
+   * @returns {number} 의미 유사도 (0-100)
+   */
+  calculateSemanticSimilarity(original, compressed) {
+    // 단순한 어휘 기반 유사도 계산
+    const originalWords = new Set(original.toLowerCase().split(/\s+/));
+    const compressedWords = new Set(compressed.toLowerCase().split(/\s+/));
+    
+    const intersection = new Set([...originalWords].filter(word => compressedWords.has(word)));
+    const union = new Set([...originalWords, ...compressedWords]);
+    
+    return union.size > 0 ? (intersection.size / union.size) * 100 : 0;
+  }
+
+  /**
+   * 정보 손실률을 계산합니다
+   * @param {string} original - 원본 콘텐츠
+   * @param {string} compressed - 압축된 콘텐츠
+   * @returns {number} 정보 손실률 (0-100)
+   */
+  calculateInformationLoss(original, compressed) {
+    const preservation = this.calculateInformationPreservation(original, compressed);
+    return 100 - preservation;
+  }
+
+  /**
+   * 가독성 점수를 계산합니다
+   * @param {string} text - 텍스트
+   * @returns {number} 가독성 점수 (0-100)
+   */
+  calculateReadabilityScore(text) {
+    const sentences = text.split(/[.!?]+/).filter(s => s.trim().length > 0);
+    const words = text.split(/\s+/).filter(w => w.trim().length > 0);
+    
+    if (sentences.length === 0 || words.length === 0) return 0;
+    
+    const avgWordsPerSentence = words.length / sentences.length;
+    const avgCharsPerWord = words.reduce((sum, word) => sum + word.length, 0) / words.length;
+    
+    // 단순한 가독성 점수 계산
+    let score = 100;
+    
+    // 문장 길이 페널티
+    if (avgWordsPerSentence > 20) score -= 20;
+    else if (avgWordsPerSentence > 15) score -= 10;
+    
+    // 단어 길이 페널티
+    if (avgCharsPerWord > 7) score -= 20;
+    else if (avgCharsPerWord > 5) score -= 10;
+    
+    return Math.max(0, Math.min(100, score));
+  }
+
+  /**
+   * 일관성 점수를 계산합니다
+   * @param {string} text - 텍스트
+   * @returns {number} 일관성 점수 (0-100)
+   */
+  calculateCoherenceScore(text) {
+    // 단순한 일관성 점수 계산
+    const lines = text.split('\n');
+    let coherenceScore = 100;
+    
+    // 빈 줄 패턴 확인
+    const emptyLinePattern = /^\s*$/;
+    const consecutiveEmptyLines = lines.reduce((count, line, index) => {
+      if (emptyLinePattern.test(line) && index > 0 && emptyLinePattern.test(lines[index - 1])) {
+        return count + 1;
+      }
+      return count;
+    }, 0);
+    
+    coherenceScore -= consecutiveEmptyLines * 2;
+    
+    // 헤더 계층 구조 확인
+    const headers = lines.filter(line => line.match(/^#{1,6}\s+/));
+    const headerLevels = headers.map(header => header.match(/^(#{1,6})/)[1].length);
+    
+    let previousLevel = 0;
+    for (const level of headerLevels) {
+      if (level - previousLevel > 1) {
+        coherenceScore -= 5; // 헤더 레벨 건너뛰기 페널티
+      }
+      previousLevel = level;
+    }
+    
+    return Math.max(0, Math.min(100, coherenceScore));
+  }
+
+  /**
+   * 완성도 점수를 계산합니다
+   * @param {string} original - 원본 콘텐츠
+   * @param {string} compressed - 압축된 콘텐츠
+   * @returns {number} 완성도 점수 (0-100)
+   */
+  calculateCompletenessScore(original, compressed) {
+    // 중요한 섹션이 유지되었는지 확인
+    const importantSections = [
+      'goal', 'objective', 'requirement', 'task', 'subtask', 'acceptance criteria',
+      '목표', '목적', '요구사항', '태스크', '하위', '승인 기준'
+    ];
+    
+    let foundSections = 0;
+    const lowerCompressed = compressed.toLowerCase();
+    
+    for (const section of importantSections) {
+      if (lowerCompressed.includes(section.toLowerCase())) {
+        foundSections++;
+      }
+    }
+    
+    const completenessRatio = foundSections / importantSections.length;
+    return completenessRatio * 100;
+  }
+
+  /**
+   * 압축 효율성을 계산합니다
+   * @param {number} compressionRatio - 압축률
+   * @param {number} informationPreservation - 정보 보존률
+   * @returns {number} 압축 효율성 (0-100)
+   */
+  calculateCompressionEfficiency(compressionRatio, informationPreservation) {
+    // 압축률과 정보 보존률의 균형을 고려한 효율성 계산
+    const alpha = 0.6; // 압축률 가중치
+    const beta = 0.4;  // 정보 보존률 가중치
+    
+    return (alpha * compressionRatio) + (beta * informationPreservation);
+  }
+
+  /**
+   * 자원 사용률을 계산합니다
+   * @param {Object} metadata - 메타데이터
+   * @returns {number} 자원 사용률 (0-100)
+   */
+  calculateResourceUtilization(metadata) {
+    // 메모리 사용량, 처리 시간 등을 고려한 자원 사용률
+    const memoryScore = metadata.memoryUsage ? Math.min(100, 100 - (metadata.memoryUsage / 1024 / 1024)) : 100;
+    const timeScore = metadata.processingTime ? Math.min(100, 100 - (metadata.processingTime / 1000)) : 100;
+    
+    return (memoryScore + timeScore) / 2;
+  }
+
+  /**
+   * 비용 효율성을 계산합니다
+   * @param {number} originalTokens - 원본 토큰 수
+   * @param {number} compressedTokens - 압축된 토큰 수
+   * @param {number} processingTime - 처리 시간
+   * @returns {number} 비용 효율성 (0-100)
+   */
+  calculateCostEffectiveness(originalTokens, compressedTokens, processingTime) {
+    const tokenSaved = originalTokens - compressedTokens;
+    const processingTimeInSeconds = processingTime / 1000;
+    
+    if (processingTimeInSeconds === 0) return 0;
+    
+    // 초당 절약된 토큰 수
+    const tokensPerSecond = tokenSaved / processingTimeInSeconds;
+    
+    // 정규화된 비용 효율성 (최대 100)
+    return Math.min(100, tokensPerSecond);
+  }
+
+  /**
+   * 에너지 효율성을 계산합니다
+   * @param {number} originalTokens - 원본 토큰 수
+   * @param {number} processingTime - 처리 시간
+   * @returns {number} 에너지 효율성 (0-100)
+   */
+  calculateEnergyEfficiency(originalTokens, processingTime) {
+    const processingTimeInSeconds = processingTime / 1000;
+    
+    if (processingTimeInSeconds === 0) return 0;
+    
+    // 초당 처리된 토큰 수
+    const tokensPerSecond = originalTokens / processingTimeInSeconds;
+    
+    // 정규화된 에너지 효율성 (최대 100)
+    return Math.min(100, tokensPerSecond / 10);
+  }
+
+  /**
+   * 전체 품질 점수를 계산합니다
+   * @param {Object} quality - 품질 메트릭
+   * @returns {number} 전체 품질 점수 (0-100)
+   */
+  calculateOverallQuality(quality) {
+    const weights = {
+      readability_score: 0.2,
+      structure_preservation: 0.25,
+      semantic_similarity: 0.25,
+      coherence_score: 0.15,
+      completeness_score: 0.15
+    };
+    
+    let totalScore = 0;
+    let totalWeight = 0;
+    
+    for (const [metric, weight] of Object.entries(weights)) {
+      if (quality[metric] !== undefined) {
+        totalScore += quality[metric] * weight;
+        totalWeight += weight;
+      }
+    }
+    
+    return totalWeight > 0 ? totalScore / totalWeight : 0;
+  }
+
+  /**
+   * 파이프라인 성능을 분석합니다
+   * @param {Array<Object>} stages - 파이프라인 스테이지
+   * @returns {Object} 파이프라인 성능 분석
+   */
+  analyzePipelinePerformance(stages) {
+    const analysis = {
+      total_stages: stages.length,
+      total_duration: stages.reduce((sum, stage) => sum + stage.duration, 0),
+      average_duration: 0,
+      slowest_stage: null,
+      fastest_stage: null,
+      stage_breakdown: []
+    };
+    
+    if (stages.length > 0) {
+      analysis.average_duration = analysis.total_duration / stages.length;
+      
+      // 가장 느린/빠른 스테이지 찾기
+      let slowest = stages[0];
+      let fastest = stages[0];
+      
+      for (const stage of stages) {
+        if (stage.duration > slowest.duration) slowest = stage;
+        if (stage.duration < fastest.duration) fastest = stage;
+      }
+      
+      analysis.slowest_stage = { name: slowest.name, duration: slowest.duration };
+      analysis.fastest_stage = { name: fastest.name, duration: fastest.duration };
+      
+      // 스테이지별 세부 분석
+      analysis.stage_breakdown = stages.map(stage => ({
+        name: stage.name,
+        duration: stage.duration,
+        percentage: (stage.duration / analysis.total_duration) * 100,
+        success: stage.success
+      }));
+    }
+    
+    return analysis;
+  }
+
+  /**
+   * 벤치마크 분석을 수행합니다
+   * @param {Object} metrics - 메트릭 데이터
+   * @returns {Object} 벤치마크 분석
+   */
+  analyzeBenchmark(metrics) {
+    const benchmark = {
+      overall_grade: 'C',
+      overall_score: 0,
+      category_grades: {},
+      recommendations: []
+    };
+    
+    let totalScore = 0;
+    let categoryCount = 0;
+    
+    // 각 카테고리별 벤치마크 분석
+    for (const [category, categoryMetrics] of Object.entries(metrics)) {
+      const categoryGrade = this.gradeCategoryMetrics(categoryMetrics);
+      benchmark.category_grades[category] = categoryGrade;
+      totalScore += categoryGrade.score;
+      categoryCount++;
+    }
+    
+    // 전체 점수 계산
+    benchmark.overall_score = categoryCount > 0 ? totalScore / categoryCount : 0;
+    benchmark.overall_grade = this.scoreToGrade(benchmark.overall_score);
+    
+    // 권장사항 생성
+    benchmark.recommendations = this.generateRecommendations(metrics, benchmark);
+    
+    return benchmark;
+  }
+
+  /**
+   * 카테고리 메트릭을 평가합니다
+   * @param {Object} categoryMetrics - 카테고리 메트릭
+   * @returns {Object} 카테고리 평가
+   */
+  gradeCategoryMetrics(categoryMetrics) {
+    const grade = {
+      score: 0,
+      grade: 'F',
+      details: {}
+    };
+    
+    let totalScore = 0;
+    let metricCount = 0;
+    
+    for (const [metric, value] of Object.entries(categoryMetrics)) {
+      if (typeof value === 'number' && this.benchmarkThresholds[metric]) {
+        const metricGrade = this.gradeMetric(metric, value);
+        grade.details[metric] = metricGrade;
+        totalScore += metricGrade.score;
+        metricCount++;
+      }
+    }
+    
+    if (metricCount > 0) {
+      grade.score = totalScore / metricCount;
+      grade.grade = this.scoreToGrade(grade.score);
+    }
+    
+    return grade;
+  }
+
+  /**
+   * 개별 메트릭을 평가합니다
+   * @param {string} metric - 메트릭 이름
+   * @param {number} value - 메트릭 값
+   * @returns {Object} 메트릭 평가
+   */
+  gradeMetric(metric, value) {
+    const thresholds = this.benchmarkThresholds[metric];
+    if (!thresholds) return { score: 50, grade: 'C' };
+    
+    let score = 0;
+    
+    if (value >= thresholds.excellent) {
+      score = 90;
+    } else if (value >= thresholds.good) {
+      score = 80;
+    } else if (value >= thresholds.acceptable) {
+      score = 70;
+    } else if (value >= thresholds.poor) {
+      score = 60;
+    } else {
+      score = 40;
+    }
+    
+    return {
+      score,
+      grade: this.scoreToGrade(score),
+      value,
+      threshold: thresholds
+    };
+  }
+
+  /**
+   * 점수를 등급으로 변환합니다
+   * @param {number} score - 점수 (0-100)
+   * @returns {string} 등급 (A-F)
+   */
+  scoreToGrade(score) {
+    if (score >= 90) return 'A';
+    if (score >= 80) return 'B';
+    if (score >= 70) return 'C';
+    if (score >= 60) return 'D';
+    return 'F';
+  }
+
+  /**
+   * 분석 결과를 생성합니다
+   * @param {Object} metrics - 메트릭 데이터
+   * @param {Object} benchmark - 벤치마크 분석
+   * @returns {Object} 분석 결과
+   */
+  generateAnalysis(metrics, benchmark) {
+    return {
+      summary: this.generateSummary(metrics),
+      strengths: this.identifyStrengths(metrics, benchmark),
+      weaknesses: this.identifyWeaknesses(metrics, benchmark),
+      recommendations: this.generateRecommendations(metrics, benchmark),
+      trend_analysis: this.analyzeTrends(),
+      comparative_analysis: this.generateComparativeAnalysis(metrics)
+    };
+  }
+
+  /**
+   * 요약을 생성합니다
+   * @param {Object} metrics - 메트릭 데이터
+   * @returns {string} 요약
+   */
+  generateSummary(metrics) {
+    const compressionRatio = metrics.compression?.token_reduction_percentage || 0;
+    const informationPreservation = metrics.compression?.information_preservation || 0;
+    const processingTime = metrics.performance?.compression_time || 0;
+    
+    return `압축률 ${compressionRatio.toFixed(1)}%로 ${informationPreservation.toFixed(1)}%의 정보를 보존하며 ${processingTime}ms 내에 처리되었습니다.`;
+  }
+
+  /**
+   * 강점을 식별합니다
+   * @param {Object} metrics - 메트릭 데이터
+   * @param {Object} benchmark - 벤치마크 분석
+   * @returns {Array<string>} 강점 목록
+   */
+  identifyStrengths(metrics, benchmark) {
+    const strengths = [];
+    
+    for (const [category, grade] of Object.entries(benchmark.category_grades)) {
+      if (grade.score >= 80) {
+        strengths.push(`${category} 카테고리에서 우수한 성능을 보였습니다 (${grade.grade}등급)`);
+      }
+    }
+    
+    return strengths;
+  }
+
+  /**
+   * 약점을 식별합니다
+   * @param {Object} metrics - 메트릭 데이터
+   * @param {Object} benchmark - 벤치마크 분석
+   * @returns {Array<string>} 약점 목록
+   */
+  identifyWeaknesses(metrics, benchmark) {
+    const weaknesses = [];
+    
+    for (const [category, grade] of Object.entries(benchmark.category_grades)) {
+      if (grade.score < 60) {
+        weaknesses.push(`${category} 카테고리에서 개선이 필요합니다 (${grade.grade}등급)`);
+      }
+    }
+    
+    return weaknesses;
+  }
+
+  /**
+   * 권장사항을 생성합니다
+   * @param {Object} metrics - 메트릭 데이터
+   * @param {Object} benchmark - 벤치마크 분석
+   * @returns {Array<string>} 권장사항 목록
+   */
+  generateRecommendations(metrics, benchmark) {
+    const recommendations = [];
+    
+    // 압축률 기반 권장사항
+    const compressionRatio = metrics.compression?.token_reduction_percentage || 0;
+    if (compressionRatio < 30) {
+      recommendations.push('압축률을 높이기 위해 더 적극적인 압축 전략을 고려하세요.');
+    } else if (compressionRatio > 80) {
+      recommendations.push('압축률이 너무 높습니다. 정보 손실을 방지하기 위해 덜 적극적인 압축을 고려하세요.');
+    }
+    
+    // 성능 기반 권장사항
+    const processingTime = metrics.performance?.compression_time || 0;
+    if (processingTime > 5000) {
+      recommendations.push('처리 시간이 오래 걸립니다. 성능 최적화를 고려하세요.');
+    }
+    
+    // 품질 기반 권장사항
+    const informationPreservation = metrics.compression?.information_preservation || 0;
+    if (informationPreservation < 70) {
+      recommendations.push('정보 보존률이 낮습니다. 중요한 정보를 더 잘 보존하는 방법을 고려하세요.');
+    }
+    
+    return recommendations;
+  }
+
+  /**
+   * 트렌드를 분석합니다
+   * @returns {Object} 트렌드 분석
+   */
+  analyzeTrends() {
+    if (this.measurementHistory.length < 2) {
+      return { message: '트렌드 분석을 위한 충분한 데이터가 없습니다.' };
+    }
+    
+    const recent = this.measurementHistory.slice(-5);
+    const trends = {};
+    
+    // 압축률 트렌드
+    const compressionRatios = recent.map(m => m.metrics.compression?.token_reduction_percentage || 0);
+    trends.compression_ratio = this.calculateTrend(compressionRatios);
+    
+    // 처리 시간 트렌드
+    const processingTimes = recent.map(m => m.metrics.performance?.compression_time || 0);
+    trends.processing_time = this.calculateTrend(processingTimes);
+    
+    // 품질 트렌드
+    const qualityScores = recent.map(m => m.metrics.quality?.overall_quality || 0);
+    trends.quality = this.calculateTrend(qualityScores);
+    
+    return trends;
+  }
+
+  /**
+   * 트렌드를 계산합니다
+   * @param {Array<number>} values - 값 배열
+   * @returns {Object} 트렌드 정보
+   */
+  calculateTrend(values) {
+    if (values.length < 2) return { trend: 'stable', change: 0 };
+    
+    const first = values[0];
+    const last = values[values.length - 1];
+    const change = ((last - first) / first) * 100;
+    
+    let trend = 'stable';
+    if (change > 5) trend = 'increasing';
+    else if (change < -5) trend = 'decreasing';
+    
+    return { trend, change: change.toFixed(1) };
+  }
+
+  /**
+   * 비교 분석을 생성합니다
+   * @param {Object} metrics - 메트릭 데이터
+   * @returns {Object} 비교 분석
+   */
+  generateComparativeAnalysis(metrics) {
+    const analysis = {
+      vs_previous: null,
+      vs_average: null,
+      vs_best: null
+    };
+    
+    if (this.measurementHistory.length > 1) {
+      const current = metrics;
+      const previous = this.measurementHistory[this.measurementHistory.length - 2].metrics;
+      
+      analysis.vs_previous = {
+        compression_ratio_change: this.calculateChange(
+          previous.compression?.token_reduction_percentage || 0,
+          current.compression?.token_reduction_percentage || 0
+        ),
+        quality_change: this.calculateChange(
+          previous.quality?.overall_quality || 0,
+          current.quality?.overall_quality || 0
+        ),
+        performance_change: this.calculateChange(
+          previous.performance?.compression_time || 0,
+          current.performance?.compression_time || 0
+        )
+      };
+    }
+    
+    return analysis;
+  }
+
+  /**
+   * 변화량을 계산합니다
+   * @param {number} previous - 이전 값
+   * @param {number} current - 현재 값
+   * @returns {Object} 변화량 정보
+   */
+  calculateChange(previous, current) {
+    const change = current - previous;
+    const changePercentage = previous > 0 ? (change / previous) * 100 : 0;
+    
+    return {
+      absolute: change,
+      percentage: changePercentage.toFixed(1),
+      direction: change > 0 ? 'increase' : change < 0 ? 'decrease' : 'stable'
+    };
+  }
+
+  /**
+   * 측정 ID를 생성합니다
+   * @returns {string} 측정 ID
+   */
+  generateMeasurementId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substr(2, 9);
+    return `metric_${timestamp}_${random}`;
+  }
+
+  /**
+   * 측정 결과를 내보냅니다
+   * @param {string} measurementId - 측정 ID
+   * @param {string} format - 내보내기 형식 ('json', 'csv', 'report')
+   * @returns {string} 내보내기 결과
+   */
+  exportMeasurement(measurementId, format = 'json') {
+    const measurement = this.measurements.get(measurementId);
+    if (!measurement) {
+      throw new Error(`측정 결과를 찾을 수 없습니다: ${measurementId}`);
+    }
+    
+    switch (format) {
+      case 'json':
+        return JSON.stringify(measurement, null, 2);
+      case 'csv':
+        return this.convertToCSV(measurement);
+      case 'report':
+        return this.generateReport(measurement);
+      default:
+        throw new Error(`지원되지 않는 형식: ${format}`);
+    }
+  }
+
+  /**
+   * CSV 형식으로 변환합니다
+   * @param {Object} measurement - 측정 결과
+   * @returns {string} CSV 문자열
+   */
+  convertToCSV(measurement) {
+    // 플랫한 구조로 변환
+    const flatData = this.flattenObject(measurement.metrics);
+    
+    const headers = Object.keys(flatData);
+    const values = Object.values(flatData);
+    
+    return [headers.join(','), values.join(',')].join('\n');
+  }
+
+  /**
+   * 객체를 평면화합니다
+   * @param {Object} obj - 객체
+   * @param {string} prefix - 접두사
+   * @returns {Object} 평면화된 객체
+   */
+  flattenObject(obj, prefix = '') {
+    const flattened = {};
+    
+    for (const [key, value] of Object.entries(obj)) {
+      const newKey = prefix ? `${prefix}.${key}` : key;
+      
+      if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        Object.assign(flattened, this.flattenObject(value, newKey));
+      } else {
+        flattened[newKey] = value;
+      }
+    }
+    
+    return flattened;
+  }
+
+  /**
+   * 보고서를 생성합니다
+   * @param {Object} measurement - 측정 결과
+   * @returns {string} 보고서
+   */
+  generateReport(measurement) {
+    const report = [];
+    
+    report.push('# 압축 성능 보고서');
+    report.push(`측정 ID: ${measurement.id}`);
+    report.push(`측정 시간: ${new Date(measurement.timestamp).toLocaleString()}`);
+    report.push('');
+    
+    // 요약
+    report.push('## 요약');
+    report.push(measurement.analysis.summary);
+    report.push('');
+    
+    // 벤치마크 결과
+    report.push('## 벤치마크 결과');
+    report.push(`전체 등급: ${measurement.benchmark.overall_grade} (${measurement.benchmark.overall_score.toFixed(1)}점)`);
+    report.push('');
+    
+    // 강점과 약점
+    if (measurement.analysis.strengths.length > 0) {
+      report.push('## 강점');
+      measurement.analysis.strengths.forEach(strength => {
+        report.push(`- ${strength}`);
+      });
+      report.push('');
+    }
+    
+    if (measurement.analysis.weaknesses.length > 0) {
+      report.push('## 약점');
+      measurement.analysis.weaknesses.forEach(weakness => {
+        report.push(`- ${weakness}`);
+      });
+      report.push('');
+    }
+    
+    // 권장사항
+    if (measurement.analysis.recommendations.length > 0) {
+      report.push('## 권장사항');
+      measurement.analysis.recommendations.forEach(rec => {
+        report.push(`- ${rec}`);
+      });
+      report.push('');
+    }
+    
+    return report.join('\n');
+  }
+
+  /**
+   * 리소스를 정리합니다
+   */
+  cleanup() {
+    if (this.tokenCounter) {
+      this.tokenCounter.cleanup();
+    }
+    this.measurements.clear();
+    this.benchmarks.clear();
+    this.measurementHistory.length = 0;
+  }
+}
+
+export default CompressionMetrics;