aiwf 0.3.22 → 0.4.0

package/src/lib/resources/utils/context-rule-parser.js

@@ -1,180 +0,0 @@
-/**
- * 페르소나 컨텍스트 규칙 파서
- * AI 페르소나별 컨텍스트 규칙을 파싱하고 처리하는 모듈
- */
-
-const fs = require('fs').promises;
-const path = require('path');
-const yaml = require('js-yaml');
-
-class ContextRuleParser {
-  constructor() {
-    this.cache = new Map();
-    this.lastModifiedTimes = new Map();
-  }
-
-  /**
-   * 페르소나 컨텍스트 규칙 파일 파싱
-   * @param {string} personaName - 페르소나 이름
-   * @returns {Object} 파싱된 컨텍스트 규칙
-   */
-  async parseContextRules(personaName) {
-    const contextPath = path.join(
-      process.cwd(),
-      '.aiwf',
-      '07_AI_PERSONAS',
-      personaName,
-      'context_rules.md'
-    );
-
-    try {
-      // 캐시 확인
-      const cached = await this.getCachedRules(contextPath);
-      if (cached) return cached;
-
-      // 파일 읽기
-      const content = await fs.readFile(contextPath, 'utf-8');
-      
-      // YAML frontmatter와 마크다운 본문 분리
-      const { frontmatter, body } = this.separateFrontmatter(content);
-      
-      // 컨텍스트 규칙 구조화
-      const rules = {
-        ...frontmatter,
-        content: body,
-        parsedAt: new Date().toISOString()
-      };
-
-      // 캐시 저장
-      this.cache.set(contextPath, rules);
-      
-      return rules;
-    } catch (error) {
-      console.error(`컨텍스트 규칙 파싱 오류 (${personaName}):`, error.message);
-      return this.getDefaultContext(personaName);
-    }
-  }
-
-  /**
-   * YAML frontmatter와 마크다운 본문 분리
-   * @param {string} content - 전체 파일 내용
-   * @returns {Object} frontmatter와 body
-   */
-  separateFrontmatter(content) {
-    const frontmatterRegex = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/;
-    const match = content.match(frontmatterRegex);
-
-    if (match) {
-      try {
-        const frontmatter = yaml.load(match[1]);
-        const body = match[2].trim();
-        return { frontmatter, body };
-      } catch (error) {
-        console.error('YAML 파싱 오류:', error);
-        return { frontmatter: {}, body: content };
-      }
-    }
-
-    return { frontmatter: {}, body: content };
-  }
-
-  /**
-   * 캐시된 규칙 확인 및 반환
-   * @param {string} filePath - 파일 경로
-   * @returns {Object|null} 캐시된 규칙 또는 null
-   */
-  async getCachedRules(filePath) {
-    try {
-      const stats = await fs.stat(filePath);
-      const lastModified = stats.mtimeMs;
-      
-      const cachedTime = this.lastModifiedTimes.get(filePath);
-      if (cachedTime && cachedTime === lastModified) {
-        return this.cache.get(filePath);
-      }
-      
-      this.lastModifiedTimes.set(filePath, lastModified);
-      return null;
-    } catch {
-      return null;
-    }
-  }
-
-  /**
-   * 기본 컨텍스트 규칙 반환
-   * @param {string} personaName - 페르소나 이름
-   * @returns {Object} 기본 컨텍스트 규칙
-   */
-  getDefaultContext(personaName) {
-    const defaults = {
-      architect: {
-        persona_name: 'architect',
-        analysis_approach: '시스템 설계 중심',
-        design_principles: ['확장성', '유지보수성', '성능'],
-        communication_style: '구조적이고 논리적',
-        content: '아키텍트 페르소나는 시스템 전체 구조를 고려하여 설계합니다.'
-      },
-      frontend: {
-        persona_name: 'frontend',
-        analysis_approach: 'UI/UX 중심',
-        design_principles: ['사용성', '접근성', '반응성'],
-        communication_style: '시각적이고 직관적',
-        content: '프론트엔드 페르소나는 사용자 경험을 최우선으로 고려합니다.'
-      },
-      backend: {
-        persona_name: 'backend',
-        analysis_approach: 'API 및 데이터 처리 중심',
-        design_principles: ['보안', '효율성', '확장성'],
-        communication_style: '기술적이고 정확함',
-        content: '백엔드 페르소나는 서버 사이드 로직과 데이터 처리에 집중합니다.'
-      },
-      data_analyst: {
-        persona_name: 'data_analyst',
-        analysis_approach: '데이터 기반 의사결정',
-        design_principles: ['정확성', '통찰력', '시각화'],
-        communication_style: '분석적이고 통계적',
-        content: '데이터 분석가 페르소나는 데이터를 통한 인사이트 도출에 집중합니다.'
-      },
-      security: {
-        persona_name: 'security',
-        analysis_approach: '보안 취약점 중심',
-        design_principles: ['보안성', '무결성', '기밀성'],
-        communication_style: '신중하고 방어적',
-        content: '보안 페르소나는 시스템의 보안 측면을 최우선으로 고려합니다.'
-      }
-    };
-
-    return defaults[personaName] || {
-      persona_name: personaName,
-      analysis_approach: '일반적 접근',
-      design_principles: ['품질', '효율성'],
-      communication_style: '표준적',
-      content: '기본 페르소나 컨텍스트입니다.'
-    };
-  }
-
-  /**
-   * 모든 페르소나의 컨텍스트 규칙 로드
-   * @returns {Object} 모든 페르소나의 컨텍스트 규칙
-   */
-  async loadAllPersonaContexts() {
-    const personas = ['architect', 'frontend', 'backend', 'data_analyst', 'security'];
-    const contexts = {};
-
-    for (const persona of personas) {
-      contexts[persona] = await this.parseContextRules(persona);
-    }
-
-    return contexts;
-  }
-
-  /**
-   * 캐시 초기화
-   */
-  clearCache() {
-    this.cache.clear();
-    this.lastModifiedTimes.clear();
-  }
-}
-
-module.exports = ContextRuleParser;

package/src/lib/resources/utils/context-token-monitor.js

@@ -1,463 +0,0 @@
-/**
- * 컨텍스트 토큰 모니터
- * 페르소나 컨텍스트 주입으로 인한 토큰 사용량을 모니터링하는 모듈
- */
-
-const TokenCounter = require('./token-counter');
-const fs = require('fs').promises;
-const path = require('path');
-
-class ContextTokenMonitor {
-  constructor() {
-    this.tokenCounter = new TokenCounter();
-    this.usageHistory = [];
-    this.personaStats = new Map();
-    this.thresholds = {
-      warning: 2000,  // 경고 임계값 (토큰)
-      critical: 3000  // 위험 임계값 (토큰)
-    };
-  }
-
-  /**
-   * 컨텍스트 주입 토큰 사용량 추적
-   * @param {Object} injectionResult - 프롬프트 주입 결과
-   * @returns {Object} 토큰 사용량 분석
-   */
-  async trackContextUsage(injectionResult) {
-    const { tokenMetrics, personaName, context } = injectionResult;
-    
-    const usage = {
-      personaName,
-      timestamp: new Date().toISOString(),
-      originalTokens: tokenMetrics.originalTokens,
-      contextTokens: tokenMetrics.contextTokens,
-      totalTokens: tokenMetrics.injectedTokens,
-      percentageIncrease: tokenMetrics.percentageIncrease,
-      contextElements: await this.analyzeContextElements(context),
-      alert: this.checkThresholds(tokenMetrics.contextTokens)
-    };
-
-    // 히스토리에 추가
-    this.usageHistory.push(usage);
-
-    // 페르소나별 통계 업데이트
-    this.updatePersonaStats(personaName, usage);
-
-    return usage;
-  }
-
-  /**
-   * 컨텍스트 요소별 토큰 사용량 분석
-   * @param {Object} context - 페르소나 컨텍스트
-   * @returns {Object} 요소별 토큰 사용량
-   */
-  async analyzeContextElements(context) {
-    const elements = {};
-
-    // 각 컨텍스트 요소의 토큰 수 계산
-    if (context.persona_name) {
-      elements.persona_name = await this.tokenCounter.estimateTokens(context.persona_name);
-    }
-
-    if (context.analysis_approach) {
-      elements.analysis_approach = await this.tokenCounter.estimateTokens(context.analysis_approach);
-    }
-
-    if (context.design_principles) {
-      const principlesText = context.design_principles.join(', ');
-      elements.design_principles = await this.tokenCounter.estimateTokens(principlesText);
-    }
-
-    if (context.communication_style) {
-      elements.communication_style = await this.tokenCounter.estimateTokens(context.communication_style);
-    }
-
-    if (context.content) {
-      elements.content = await this.tokenCounter.estimateTokens(context.content);
-    }
-
-    // 총 토큰 수
-    elements.total = Object.values(elements).reduce((sum, tokens) => sum + tokens, 0);
-
-    return elements;
-  }
-
-  /**
-   * 임계값 확인
-   * @param {number} contextTokens - 컨텍스트 토큰 수
-   * @returns {Object} 알림 정보
-   */
-  checkThresholds(contextTokens) {
-    if (contextTokens >= this.thresholds.critical) {
-      return {
-        level: 'critical',
-        message: `컨텍스트 토큰이 위험 수준(${this.thresholds.critical})을 초과했습니다: ${contextTokens}`
-      };
-    } else if (contextTokens >= this.thresholds.warning) {
-      return {
-        level: 'warning',
-        message: `컨텍스트 토큰이 경고 수준(${this.thresholds.warning})에 도달했습니다: ${contextTokens}`
-      };
-    }
-    return null;
-  }
-
-  /**
-   * 페르소나별 통계 업데이트
-   * @param {string} personaName - 페르소나 이름
-   * @param {Object} usage - 사용량 정보
-   */
-  updatePersonaStats(personaName, usage) {
-    if (!this.personaStats.has(personaName)) {
-      this.personaStats.set(personaName, {
-        totalUsages: 0,
-        totalContextTokens: 0,
-        averageContextTokens: 0,
-        maxContextTokens: 0,
-        minContextTokens: Infinity,
-        warningCount: 0,
-        criticalCount: 0
-      });
-    }
-
-    const stats = this.personaStats.get(personaName);
-    
-    // 통계 업데이트
-    stats.totalUsages++;
-    stats.totalContextTokens += usage.contextTokens;
-    stats.averageContextTokens = stats.totalContextTokens / stats.totalUsages;
-    stats.maxContextTokens = Math.max(stats.maxContextTokens, usage.contextTokens);
-    stats.minContextTokens = Math.min(stats.minContextTokens, usage.contextTokens);
-
-    // 알림 카운트
-    if (usage.alert) {
-      if (usage.alert.level === 'warning') stats.warningCount++;
-      if (usage.alert.level === 'critical') stats.criticalCount++;
-    }
-
-    this.personaStats.set(personaName, stats);
-  }
-
-  /**
-   * 토큰 사용량 리포트 생성
-   * @param {Object} options - 리포트 옵션
-   * @returns {Object} 토큰 사용량 리포트
-   */
-  generateReport(options = {}) {
-    const { 
-      startDate = null, 
-      endDate = null, 
-      personaName = null,
-      format = 'summary' 
-    } = options;
-
-    // 필터링된 데이터 가져오기
-    let filteredHistory = this.filterHistory(startDate, endDate, personaName);
-
-    if (format === 'detailed') {
-      return this.generateDetailedReport(filteredHistory);
-    } else {
-      return this.generateSummaryReport(filteredHistory);
-    }
-  }
-
-  /**
-   * 히스토리 필터링
-   * @param {Date} startDate - 시작 날짜
-   * @param {Date} endDate - 종료 날짜
-   * @param {string} personaName - 페르소나 이름
-   * @returns {Array} 필터링된 히스토리
-   */
-  filterHistory(startDate, endDate, personaName) {
-    let filtered = this.usageHistory;
-
-    if (startDate) {
-      filtered = filtered.filter(u => new Date(u.timestamp) >= startDate);
-    }
-
-    if (endDate) {
-      filtered = filtered.filter(u => new Date(u.timestamp) <= endDate);
-    }
-
-    if (personaName) {
-      filtered = filtered.filter(u => u.personaName === personaName);
-    }
-
-    return filtered;
-  }
-
-  /**
-   * 요약 리포트 생성
-   * @param {Array} history - 필터링된 히스토리
-   * @returns {Object} 요약 리포트
-   */
-  generateSummaryReport(history) {
-    if (history.length === 0) {
-      return { message: '해당 기간의 데이터가 없습니다.' };
-    }
-
-    const totalContextTokens = history.reduce((sum, u) => sum + u.contextTokens, 0);
-    const averageContextTokens = totalContextTokens / history.length;
-    const maxUsage = history.reduce((max, u) => u.contextTokens > max.contextTokens ? u : max);
-    const minUsage = history.reduce((min, u) => u.contextTokens < min.contextTokens ? u : min);
-
-    // 페르소나별 집계
-    const personaSummary = {};
-    history.forEach(usage => {
-      if (!personaSummary[usage.personaName]) {
-        personaSummary[usage.personaName] = {
-          count: 0,
-          totalTokens: 0,
-          alerts: { warning: 0, critical: 0 }
-        };
-      }
-      
-      personaSummary[usage.personaName].count++;
-      personaSummary[usage.personaName].totalTokens += usage.contextTokens;
-      
-      if (usage.alert) {
-        personaSummary[usage.personaName].alerts[usage.alert.level]++;
-      }
-    });
-
-    return {
-      period: {
-        start: history[0].timestamp,
-        end: history[history.length - 1].timestamp
-      },
-      totalUsages: history.length,
-      tokenStats: {
-        total: totalContextTokens,
-        average: Math.round(averageContextTokens),
-        max: {
-          tokens: maxUsage.contextTokens,
-          persona: maxUsage.personaName,
-          timestamp: maxUsage.timestamp
-        },
-        min: {
-          tokens: minUsage.contextTokens,
-          persona: minUsage.personaName,
-          timestamp: minUsage.timestamp
-        }
-      },
-      personaSummary,
-      alerts: {
-        total: history.filter(u => u.alert).length,
-        warning: history.filter(u => u.alert?.level === 'warning').length,
-        critical: history.filter(u => u.alert?.level === 'critical').length
-      }
-    };
-  }
-
-  /**
-   * 상세 리포트 생성
-   * @param {Array} history - 필터링된 히스토리
-   * @returns {Object} 상세 리포트
-   */
-  generateDetailedReport(history) {
-    const summary = this.generateSummaryReport(history);
-    
-    // 시간대별 분석
-    const hourlyAnalysis = this.analyzeHourlyPattern(history);
-    
-    // 컨텍스트 요소별 분석
-    const elementAnalysis = this.analyzeContextElements(history);
-    
-    // 트렌드 분석
-    const trendAnalysis = this.analyzeTrends(history);
-
-    return {
-      summary,
-      hourlyAnalysis,
-      elementAnalysis,
-      trendAnalysis,
-      rawData: history
-    };
-  }
-
-  /**
-   * 시간대별 패턴 분석
-   * @param {Array} history - 필터링된 히스토리
-   * @returns {Object} 시간대별 분석
-   */
-  analyzeHourlyPattern(history) {
-    const hourlyData = {};
-    
-    history.forEach(usage => {
-      const hour = new Date(usage.timestamp).getHours();
-      if (!hourlyData[hour]) {
-        hourlyData[hour] = {
-          count: 0,
-          totalTokens: 0
-        };
-      }
-      hourlyData[hour].count++;
-      hourlyData[hour].totalTokens += usage.contextTokens;
-    });
-
-    // 평균 계산
-    Object.keys(hourlyData).forEach(hour => {
-      hourlyData[hour].average = hourlyData[hour].totalTokens / hourlyData[hour].count;
-    });
-
-    return hourlyData;
-  }
-
-  /**
-   * 트렌드 분석
-   * @param {Array} history - 필터링된 히스토리
-   * @returns {Object} 트렌드 정보
-   */
-  analyzeTrends(history) {
-    if (history.length < 2) {
-      return { message: '트렌드 분석을 위한 데이터가 부족합니다.' };
-    }
-
-    // 시간 순 정렬
-    const sorted = [...history].sort((a, b) => 
-      new Date(a.timestamp) - new Date(b.timestamp)
-    );
-
-    // 이동 평균 계산
-    const windowSize = Math.min(5, Math.floor(sorted.length / 3));
-    const movingAverages = [];
-
-    for (let i = windowSize - 1; i < sorted.length; i++) {
-      const window = sorted.slice(i - windowSize + 1, i + 1);
-      const average = window.reduce((sum, u) => sum + u.contextTokens, 0) / windowSize;
-      movingAverages.push({
-        timestamp: sorted[i].timestamp,
-        average: Math.round(average)
-      });
-    }
-
-    // 증가/감소 트렌드 판단
-    const firstAvg = movingAverages[0].average;
-    const lastAvg = movingAverages[movingAverages.length - 1].average;
-    const trendDirection = lastAvg > firstAvg ? 'increasing' : 
-                          lastAvg < firstAvg ? 'decreasing' : 'stable';
-    const trendPercentage = ((lastAvg - firstAvg) / firstAvg * 100).toFixed(2);
-
-    return {
-      direction: trendDirection,
-      changePercentage: trendPercentage + '%',
-      movingAverages,
-      prediction: this.predictNextUsage(movingAverages)
-    };
-  }
-
-  /**
-   * 다음 사용량 예측
-   * @param {Array} movingAverages - 이동 평균 데이터
-   * @returns {number} 예측 토큰 수
-   */
-  predictNextUsage(movingAverages) {
-    if (movingAverages.length < 3) {
-      return null;
-    }
-
-    // 간단한 선형 예측
-    const recent = movingAverages.slice(-3);
-    const trend = (recent[2].average - recent[0].average) / 2;
-    const prediction = recent[2].average + trend;
-
-    return Math.round(Math.max(0, prediction));
-  }
-
-  /**
-   * 토큰 사용량 최적화 제안
-   * @param {string} personaName - 페르소나 이름
-   * @returns {Object} 최적화 제안
-   */
-  getOptimizationSuggestions(personaName) {
-    const stats = this.personaStats.get(personaName);
-    if (!stats) {
-      return { message: '해당 페르소나의 사용 기록이 없습니다.' };
-    }
-
-    const suggestions = [];
-
-    // 평균 토큰 사용량이 높은 경우
-    if (stats.averageContextTokens > this.thresholds.warning * 0.8) {
-      suggestions.push({
-        type: 'high_average',
-        message: '평균 컨텍스트 토큰 사용량이 높습니다. 컨텍스트 내용을 간소화하는 것을 고려하세요.',
-        currentAverage: Math.round(stats.averageContextTokens),
-        recommendedMax: Math.round(this.thresholds.warning * 0.8)
-      });
-    }
-
-    // 경고/위험 발생률이 높은 경우
-    const alertRate = (stats.warningCount + stats.criticalCount) / stats.totalUsages;
-    if (alertRate > 0.2) {
-      suggestions.push({
-        type: 'high_alert_rate',
-        message: '토큰 한계 초과가 자주 발생합니다. 컨텍스트 압축을 활성화하세요.',
-        alertRate: (alertRate * 100).toFixed(2) + '%',
-        warningCount: stats.warningCount,
-        criticalCount: stats.criticalCount
-      });
-    }
-
-    // 최대 사용량이 위험 수준에 근접한 경우
-    if (stats.maxContextTokens > this.thresholds.critical * 0.9) {
-      suggestions.push({
-        type: 'near_critical',
-        message: '최대 토큰 사용량이 위험 수준에 근접합니다. 긴 컨텍스트를 분할하거나 요약하세요.',
-        maxTokens: stats.maxContextTokens,
-        criticalThreshold: this.thresholds.critical
-      });
-    }
-
-    return {
-      personaName,
-      suggestions,
-      currentStats: stats
-    };
-  }
-
-  /**
-   * 리포트 파일로 저장
-   * @param {Object} report - 리포트 데이터
-   * @param {string} filename - 파일명
-   */
-  async saveReport(report, filename) {
-    const reportsDir = path.join(process.cwd(), '.aiwf', 'reports', 'token-usage');
-    
-    // 디렉토리 생성
-    await fs.mkdir(reportsDir, { recursive: true });
-    
-    // 파일 경로
-    const filePath = path.join(reportsDir, filename);
-    
-    // JSON 형식으로 저장
-    await fs.writeFile(filePath, JSON.stringify(report, null, 2), 'utf-8');
-    
-    console.log(`토큰 사용량 리포트 저장: ${filePath}`);
-    return filePath;
-  }
-
-  /**
-   * 임계값 설정
-   * @param {Object} thresholds - 새로운 임계값
-   */
-  setThresholds(thresholds) {
-    if (thresholds.warning) {
-      this.thresholds.warning = thresholds.warning;
-    }
-    if (thresholds.critical) {
-      this.thresholds.critical = thresholds.critical;
-    }
-  }
-
-  /**
-   * 모니터링 데이터 초기화
-   */
-  reset() {
-    this.usageHistory = [];
-    this.personaStats.clear();
-    console.log('토큰 모니터링 데이터가 초기화되었습니다.');
-  }
-}
-
-module.exports = ContextTokenMonitor;