aiwf 0.3.1 → 0.3.2

package/claude-code/aiwf/ko/utils/context-compressor.js

@@ -0,0 +1,583 @@
+import { AggressiveCompressionStrategy, BalancedCompressionStrategy, MinimalCompressionStrategy } from './compression-strategies.js';
+import { TextSummarizer } from './text-summarizer.js';
+import { ContentNormalizer } from './content-normalizer.js';
+import { ImportanceClassifier } from './importance-classifier.js';
+import { InformationFilter } from './information-filter.js';
+import { TokenCounter } from './token-counter.js';
+import { TokenTracker } from './token-tracker.js';
+
+/**
+ * 통합 Context 압축 시스템
+ */
+export class ContextCompressor {
+  constructor(mode = 'balanced') {
+    this.mode = mode;
+    this.tokenCounter = new TokenCounter();
+    this.tokenTracker = new TokenTracker();
+    this.initializeStrategies();
+    this.initializeComponents();
+  }
+
+  /**
+   * 압축 전략을 초기화합니다
+   */
+  initializeStrategies() {
+    this.strategies = {
+      aggressive: new AggressiveCompressionStrategy(),
+      balanced: new BalancedCompressionStrategy(),
+      minimal: new MinimalCompressionStrategy()
+    };
+  }
+
+  /**
+   * 컴포넌트를 초기화합니다
+   */
+  initializeComponents() {
+    this.summarizer = new TextSummarizer();
+    this.normalizer = new ContentNormalizer();
+    this.classifier = new ImportanceClassifier();
+    this.filter = new InformationFilter();
+  }
+
+  /**
+   * 콘텐츠를 압축합니다
+   * @param {string} content - 압축할 콘텐츠
+   * @param {Object} options - 압축 옵션
+   * @returns {Object} 압축 결과
+   */
+  async compress(content, options = {}) {
+    const startTime = Date.now();
+    
+    const {
+      strategy = this.mode,
+      targetRatio = null,
+      maxTokens = null,
+      preserveStructure = true,
+      enableSummarization = true,
+      enableNormalization = true,
+      enableFiltering = true,
+      customFilters = {},
+      generateMetadata = true
+    } = options;
+
+    try {
+      // 원본 토큰 수 계산
+      const originalTokens = this.tokenCounter.countTokens(content);
+      
+      // 압축 파이프라인 실행
+      const pipeline = this.createCompressionPipeline(strategy, options);
+      const result = await this.executePipeline(pipeline, content);
+
+      // 압축 결과 구성
+      const compressedTokens = this.tokenCounter.countTokens(result.content);
+      const compressionRatio = ((originalTokens - compressedTokens) / originalTokens) * 100;
+
+      // 토큰 추적
+      this.tokenTracker.trackCompression(originalTokens, compressedTokens);
+
+      const compressionResult = {
+        original: content,
+        compressed: result.content,
+        originalTokens,
+        compressedTokens,
+        compressionRatio,
+        tokensReduced: originalTokens - compressedTokens,
+        strategy,
+        processingTime: Date.now() - startTime,
+        success: true
+      };
+
+      if (generateMetadata) {
+        compressionResult.metadata = {
+          ...result.metadata,
+          compressionId: this.generateCompressionId(),
+          timestamp: new Date().toISOString(),
+          pipelineStages: result.stages,
+          tokenTracker: this.tokenTracker.generateReport()
+        };
+      }
+
+      return compressionResult;
+
+    } catch (error) {
+      console.error('압축 중 오류 발생:', error);
+      return {
+        original: content,
+        compressed: content,
+        originalTokens: this.tokenCounter.countTokens(content),
+        compressedTokens: this.tokenCounter.countTokens(content),
+        compressionRatio: 0,
+        tokensReduced: 0,
+        strategy,
+        processingTime: Date.now() - startTime,
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * 압축 파이프라인을 생성합니다
+   * @param {string} strategy - 압축 전략
+   * @param {Object} options - 옵션
+   * @returns {Array<Object>} 파이프라인 스테이지
+   */
+  createCompressionPipeline(strategy, options) {
+    const pipeline = [];
+
+    // 1. 토큰 분석 스테이지
+    pipeline.push({
+      name: 'TokenAnalysis',
+      processor: this.tokenAnalysisStage.bind(this),
+      options: {}
+    });
+
+    // 2. 중요도 분석 스테이지
+    pipeline.push({
+      name: 'ImportanceAnalysis',
+      processor: this.importanceAnalysisStage.bind(this),
+      options: {}
+    });
+
+    // 3. 정규화 스테이지 (옵션)
+    if (options.enableNormalization) {
+      pipeline.push({
+        name: 'Normalization',
+        processor: this.normalizationStage.bind(this),
+        options: {}
+      });
+    }
+
+    // 4. 필터링 스테이지 (옵션)
+    if (options.enableFiltering) {
+      pipeline.push({
+        name: 'Filtering',
+        processor: this.filteringStage.bind(this),
+        options: {
+          customFilters: options.customFilters || {},
+          maxTokens: options.maxTokens
+        }
+      });
+    }
+
+    // 5. 요약 스테이지 (옵션)
+    if (options.enableSummarization) {
+      pipeline.push({
+        name: 'Summarization',
+        processor: this.summarizationStage.bind(this),
+        options: {
+          targetRatio: options.targetRatio || 0.7
+        }
+      });
+    }
+
+    // 6. 전략 압축 스테이지
+    pipeline.push({
+      name: 'StrategyCompression',
+      processor: this.strategyCompressionStage.bind(this),
+      options: {
+        strategy,
+        preserveStructure: options.preserveStructure
+      }
+    });
+
+    // 7. 검증 스테이지
+    pipeline.push({
+      name: 'Validation',
+      processor: this.validationStage.bind(this),
+      options: {}
+    });
+
+    return pipeline;
+  }
+
+  /**
+   * 파이프라인을 실행합니다
+   * @param {Array<Object>} pipeline - 파이프라인 스테이지
+   * @param {string} content - 처리할 콘텐츠
+   * @returns {Object} 파이프라인 결과
+   */
+  async executePipeline(pipeline, content) {
+    let result = { content, metadata: {}, stages: [] };
+
+    for (const stage of pipeline) {
+      const stageStartTime = Date.now();
+      
+      try {
+        const stageResult = await stage.processor(result, stage.options);
+        result = {
+          ...result,
+          ...stageResult,
+          stages: [...result.stages, {
+            name: stage.name,
+            duration: Date.now() - stageStartTime,
+            success: true,
+            tokensAfter: this.tokenCounter.countTokens(stageResult.content)
+          }]
+        };
+      } catch (error) {
+        console.error(`파이프라인 스테이지 ${stage.name}에서 오류 발생:`, error);
+        result.stages.push({
+          name: stage.name,
+          duration: Date.now() - stageStartTime,
+          success: false,
+          error: error.message
+        });
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * 토큰 분석 스테이지
+   * @param {Object} input - 입력 데이터
+   * @param {Object} options - 옵션
+   * @returns {Object} 스테이지 결과
+   */
+  async tokenAnalysisStage(input, options) {
+    const tokenAnalysis = this.tokenCounter.analyzeTokenDistribution(input.content);
+    
+    return {
+      content: input.content,
+      metadata: {
+        ...input.metadata,
+        tokenAnalysis,
+        originalTokens: this.tokenCounter.countTokens(input.content)
+      }
+    };
+  }
+
+  /**
+   * 중요도 분석 스테이지
+   * @param {Object} input - 입력 데이터
+   * @param {Object} options - 옵션
+   * @returns {Object} 스테이지 결과
+   */
+  async importanceAnalysisStage(input, options) {
+    const importanceResult = this.classifier.analyzeImportance(input.content);
+    
+    return {
+      content: input.content,
+      metadata: {
+        ...input.metadata,
+        importanceAnalysis: importanceResult
+      }
+    };
+  }
+
+  /**
+   * 정규화 스테이지
+   * @param {Object} input - 입력 데이터
+   * @param {Object} options - 옵션
+   * @returns {Object} 스테이지 결과
+   */
+  async normalizationStage(input, options) {
+    const normalizeResult = this.normalizer.normalize(input.content);
+    
+    return {
+      content: normalizeResult.normalized,
+      metadata: {
+        ...input.metadata,
+        normalization: normalizeResult.metadata
+      }
+    };
+  }
+
+  /**
+   * 필터링 스테이지
+   * @param {Object} input - 입력 데이터
+   * @param {Object} options - 옵션
+   * @returns {Object} 스테이지 결과
+   */
+  async filteringStage(input, options) {
+    const filterResult = this.filter.filter(input.content, {
+      customRules: options.customFilters,
+      maxTokens: options.maxTokens
+    });
+    
+    return {
+      content: filterResult.filtered,
+      metadata: {
+        ...input.metadata,
+        filtering: filterResult.metadata
+      }
+    };
+  }
+
+  /**
+   * 요약 스테이지
+   * @param {Object} input - 입력 데이터
+   * @param {Object} options - 옵션
+   * @returns {Object} 스테이지 결과
+   */
+  async summarizationStage(input, options) {
+    const summarizeResult = this.summarizer.summarize(input.content, {
+      targetRatio: options.targetRatio
+    });
+    
+    return {
+      content: summarizeResult.summary,
+      metadata: {
+        ...input.metadata,
+        summarization: summarizeResult.metadata
+      }
+    };
+  }
+
+  /**
+   * 전략 압축 스테이지
+   * @param {Object} input - 입력 데이터
+   * @param {Object} options - 옵션
+   * @returns {Object} 스테이지 결과
+   */
+  async strategyCompressionStage(input, options) {
+    const strategy = this.strategies[options.strategy];
+    if (!strategy) {
+      throw new Error(`압축 전략을 찾을 수 없습니다: ${options.strategy}`);
+    }
+
+    const compressionResult = strategy.compress(input.content, {
+      preserveStructure: options.preserveStructure
+    });
+    
+    return {
+      content: compressionResult.content,
+      metadata: {
+        ...input.metadata,
+        strategyCompression: compressionResult.metadata
+      }
+    };
+  }
+
+  /**
+   * 검증 스테이지
+   * @param {Object} input - 입력 데이터
+   * @param {Object} options - 옵션
+   * @returns {Object} 스테이지 결과
+   */
+  async validationStage(input, options) {
+    const validationResult = this.validateCompression(input.content, input.metadata);
+    
+    return {
+      content: input.content,
+      metadata: {
+        ...input.metadata,
+        validation: validationResult
+      }
+    };
+  }
+
+  /**
+   * 압축 결과를 검증합니다
+   * @param {string} content - 압축된 콘텐츠
+   * @param {Object} metadata - 메타데이터
+   * @returns {Object} 검증 결과
+   */
+  validateCompression(content, metadata) {
+    const validation = {
+      isValid: true,
+      warnings: [],
+      errors: [],
+      qualityScore: 0
+    };
+
+    // 1. 콘텐츠 유효성 검증
+    if (!content || content.trim().length === 0) {
+      validation.isValid = false;
+      validation.errors.push('압축된 콘텐츠가 비어있습니다.');
+    }
+
+    // 2. 압축률 검증
+    if (metadata.originalTokens && metadata.originalTokens > 0) {
+      const currentTokens = this.tokenCounter.countTokens(content);
+      const compressionRatio = ((metadata.originalTokens - currentTokens) / metadata.originalTokens) * 100;
+      
+      if (compressionRatio < 5) {
+        validation.warnings.push('압축률이 낮습니다 (5% 미만).');
+      } else if (compressionRatio > 90) {
+        validation.warnings.push('압축률이 너무 높습니다 (90% 초과). 중요한 정보가 손실될 수 있습니다.');
+      }
+      
+      // 품질 점수 계산
+      validation.qualityScore = this.calculateQualityScore(compressionRatio, metadata);
+    }
+
+    // 3. 구조 유지 검증
+    if (metadata.importanceAnalysis) {
+      const criticalSections = metadata.importanceAnalysis.sections.filter(s => s.importance === 'critical');
+      const preservedCritical = criticalSections.filter(s => 
+        content.includes(s.name) || content.includes(s.content.substring(0, 50))
+      );
+      
+      if (preservedCritical.length < criticalSections.length) {
+        validation.warnings.push('일부 중요한 섹션이 압축 과정에서 손실되었을 수 있습니다.');
+      }
+    }
+
+    return validation;
+  }
+
+  /**
+   * 품질 점수를 계산합니다
+   * @param {number} compressionRatio - 압축률
+   * @param {Object} metadata - 메타데이터
+   * @returns {number} 품질 점수 (0-100)
+   */
+  calculateQualityScore(compressionRatio, metadata) {
+    let score = 0;
+
+    // 압축률 점수 (40점 만점)
+    if (compressionRatio >= 20 && compressionRatio <= 70) {
+      score += 40;
+    } else if (compressionRatio >= 10 && compressionRatio <= 80) {
+      score += 30;
+    } else if (compressionRatio >= 5 && compressionRatio <= 90) {
+      score += 20;
+    } else {
+      score += 10;
+    }
+
+    // 정보 보존 점수 (30점 만점)
+    if (metadata.importanceAnalysis) {
+      const preservedImportant = metadata.importanceAnalysis.sections.filter(s => 
+        s.importance === 'critical' || s.importance === 'high'
+      ).length;
+      const totalImportant = metadata.importanceAnalysis.sections.filter(s => 
+        s.importance === 'critical' || s.importance === 'high'
+      ).length;
+      
+      if (totalImportant > 0) {
+        score += (preservedImportant / totalImportant) * 30;
+      } else {
+        score += 30;
+      }
+    } else {
+      score += 20; // 기본 점수
+    }
+
+    // 구조 유지 점수 (20점 만점)
+    if (metadata.strategyCompression) {
+      score += metadata.strategyCompression.preservedSections ? 20 : 10;
+    } else {
+      score += 15; // 기본 점수
+    }
+
+    // 성능 점수 (10점 만점)
+    score += 10; // 기본 점수 (실제로는 처리 시간 등을 고려)
+
+    return Math.min(100, Math.max(0, score));
+  }
+
+  /**
+   * 압축된 콘텐츠를 복원합니다
+   * @param {string} compressedContent - 압축된 콘텐츠
+   * @param {Object} metadata - 복원 메타데이터
+   * @returns {Object} 복원 결과
+   */
+  async decompress(compressedContent, metadata) {
+    const startTime = Date.now();
+
+    try {
+      // 메타데이터에서 압축 정보 추출
+      const compressionStrategy = metadata.strategyCompression?.strategy || 'balanced';
+      const strategy = this.strategies[compressionStrategy];
+
+      if (!strategy) {
+        throw new Error(`복원 전략을 찾을 수 없습니다: ${compressionStrategy}`);
+      }
+
+      // 전략별 복원 수행
+      const decompressed = strategy.decompress(compressedContent, metadata);
+
+      const result = {
+        compressed: compressedContent,
+        decompressed,
+        strategy: compressionStrategy,
+        processingTime: Date.now() - startTime,
+        success: true,
+        metadata: {
+          decompressionId: this.generateCompressionId(),
+          timestamp: new Date().toISOString(),
+          originalMetadata: metadata
+        }
+      };
+
+      return result;
+
+    } catch (error) {
+      console.error('복원 중 오류 발생:', error);
+      return {
+        compressed: compressedContent,
+        decompressed: compressedContent, // 복원 실패 시 압축된 콘텐츠 반환
+        strategy: 'fallback',
+        processingTime: Date.now() - startTime,
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * 압축 ID를 생성합니다
+   * @returns {string} 압축 ID
+   */
+  generateCompressionId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substr(2, 9);
+    return `comp_${timestamp}_${random}`;
+  }
+
+  /**
+   * 압축 통계를 반환합니다
+   * @returns {Object} 압축 통계
+   */
+  getStatistics() {
+    return {
+      tokenTracker: this.tokenTracker.getSessionStats(),
+      filter: this.filter.getStatistics(),
+      supportedStrategies: Object.keys(this.strategies),
+      currentMode: this.mode
+    };
+  }
+
+  /**
+   * 모드를 변경합니다
+   * @param {string} mode - 새로운 모드
+   */
+  setMode(mode) {
+    if (this.strategies[mode]) {
+      this.mode = mode;
+    } else {
+      throw new Error(`지원되지 않는 압축 모드: ${mode}`);
+    }
+  }
+
+  /**
+   * 사용자 정의 전략을 추가합니다
+   * @param {string} name - 전략 이름
+   * @param {Object} strategy - 전략 객체
+   */
+  addStrategy(name, strategy) {
+    this.strategies[name] = strategy;
+  }
+
+  /**
+   * 리소스를 정리합니다
+   */
+  cleanup() {
+    if (this.tokenCounter) this.tokenCounter.cleanup();
+    if (this.tokenTracker) this.tokenTracker.cleanup();
+    if (this.summarizer) this.summarizer.cleanup();
+    if (this.normalizer) this.normalizer.cleanup();
+    if (this.classifier) this.classifier.cleanup();
+    if (this.filter) this.filter.cleanup();
+    
+    // 전략들 정리
+    Object.values(this.strategies).forEach(strategy => {
+      if (strategy.cleanup) strategy.cleanup();
+    });
+  }
+}
+
+export default ContextCompressor;