aiwf 0.3.6 → 0.3.8

package/src/lib/resources/utils/token-storage.js

@@ -0,0 +1,433 @@
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * 토큰 사용량 데이터를 저장하고 관리하는 클래스
+ */
+export class TokenStorage {
+  constructor(baseDir = '.aiwf/token-data') {
+    this.baseDir = baseDir;
+    this.dataFile = path.join(baseDir, 'token-usage.json');
+    this.sessionDir = path.join(baseDir, 'sessions');
+    this.reportsDir = path.join(baseDir, 'reports');
+    
+    this.ensureDirectories();
+    this.loadData();
+  }
+
+  /**
+   * 필요한 디렉토리를 생성합니다
+   */
+  ensureDirectories() {
+    try {
+      const dirs = [this.baseDir, this.sessionDir, this.reportsDir];
+      for (const dir of dirs) {
+        if (!fs.existsSync(dir)) {
+          fs.mkdirSync(dir, { recursive: true });
+        }
+      }
+    } catch (error) {
+      console.error('디렉토리 생성 중 오류 발생:', error);
+    }
+  }
+
+  /**
+   * 토큰 사용량 데이터를 로드합니다
+   */
+  loadData() {
+    try {
+      if (fs.existsSync(this.dataFile)) {
+        const data = JSON.parse(fs.readFileSync(this.dataFile, 'utf8'));
+        this.data = {
+          totalTokens: 0,
+          sessionsCount: 0,
+          lastUpdated: Date.now(),
+          dailyUsage: {},
+          commandStats: {},
+          compressionStats: {
+            totalOriginal: 0,
+            totalCompressed: 0,
+            totalSaved: 0,
+            avgRatio: 0
+          },
+          ...data
+        };
+      } else {
+        this.data = {
+          totalTokens: 0,
+          sessionsCount: 0,
+          lastUpdated: Date.now(),
+          dailyUsage: {},
+          commandStats: {},
+          compressionStats: {
+            totalOriginal: 0,
+            totalCompressed: 0,
+            totalSaved: 0,
+            avgRatio: 0
+          }
+        };
+      }
+    } catch (error) {
+      console.error('데이터 로드 중 오류 발생:', error);
+      this.data = this.getDefaultData();
+    }
+  }
+
+  /**
+   * 기본 데이터 구조를 반환합니다
+   * @returns {Object} 기본 데이터 구조
+   */
+  getDefaultData() {
+    return {
+      totalTokens: 0,
+      sessionsCount: 0,
+      lastUpdated: Date.now(),
+      dailyUsage: {},
+      commandStats: {},
+      compressionStats: {
+        totalOriginal: 0,
+        totalCompressed: 0,
+        totalSaved: 0,
+        avgRatio: 0
+      }
+    };
+  }
+
+  /**
+   * 데이터를 저장합니다
+   */
+  saveData() {
+    try {
+      this.data.lastUpdated = Date.now();
+      fs.writeFileSync(this.dataFile, JSON.stringify(this.data, null, 2));
+    } catch (error) {
+      console.error('데이터 저장 중 오류 발생:', error);
+    }
+  }
+
+  /**
+   * 세션 토큰 사용량을 기록합니다
+   * @param {Object} sessionData - 세션 데이터
+   */
+  recordSessionUsage(sessionData) {
+    try {
+      const today = new Date().toISOString().split('T')[0];
+      
+      // 총 토큰 수 업데이트
+      this.data.totalTokens += sessionData.totalTokens;
+      this.data.sessionsCount++;
+      
+      // 일일 사용량 업데이트
+      if (!this.data.dailyUsage[today]) {
+        this.data.dailyUsage[today] = {
+          tokens: 0,
+          sessions: 0,
+          commands: 0
+        };
+      }
+      
+      this.data.dailyUsage[today].tokens += sessionData.totalTokens;
+      this.data.dailyUsage[today].sessions++;
+      this.data.dailyUsage[today].commands += sessionData.commands.length;
+      
+      // 명령어별 통계 업데이트
+      for (const command of sessionData.commands) {
+        if (!this.data.commandStats[command.command]) {
+          this.data.commandStats[command.command] = {
+            count: 0,
+            totalTokens: 0,
+            avgTokens: 0
+          };
+        }
+        
+        const stats = this.data.commandStats[command.command];
+        stats.count++;
+        stats.totalTokens += command.totalTokens;
+        stats.avgTokens = Math.round(stats.totalTokens / stats.count);
+      }
+      
+      // 압축 통계 업데이트
+      if (sessionData.compressions) {
+        for (const compression of sessionData.compressions) {
+          this.data.compressionStats.totalOriginal += compression.originalTokens;
+          this.data.compressionStats.totalCompressed += compression.compressedTokens;
+          this.data.compressionStats.totalSaved += compression.savedTokens;
+        }
+        
+        // 평균 압축률 계산
+        if (this.data.compressionStats.totalOriginal > 0) {
+          this.data.compressionStats.avgRatio = 
+            (this.data.compressionStats.totalSaved / this.data.compressionStats.totalOriginal) * 100;
+        }
+      }
+      
+      this.saveData();
+    } catch (error) {
+      console.error('세션 사용량 기록 중 오류 발생:', error);
+    }
+  }
+
+  /**
+   * 토큰 사용량 보고서를 생성합니다
+   * @param {string} type - 보고서 타입 ('daily', 'weekly', 'monthly')
+   * @returns {Object} 보고서 데이터
+   */
+  generateUsageReport(type = 'daily') {
+    try {
+      const report = {
+        type,
+        generatedAt: Date.now(),
+        period: this.getPeriod(type),
+        summary: {
+          totalTokens: this.data.totalTokens,
+          totalSessions: this.data.sessionsCount,
+          avgTokensPerSession: this.data.sessionsCount > 0 ? 
+            Math.round(this.data.totalTokens / this.data.sessionsCount) : 0
+        },
+        dailyUsage: this.getDailyUsageForPeriod(type),
+        topCommands: this.getTopCommands(10),
+        compressionStats: this.data.compressionStats,
+        trends: this.calculateTrends(type)
+      };
+      
+      // 보고서 저장
+      const reportFile = path.join(this.reportsDir, `${type}_report_${Date.now()}.json`);
+      fs.writeFileSync(reportFile, JSON.stringify(report, null, 2));
+      
+      return report;
+    } catch (error) {
+      console.error('보고서 생성 중 오류 발생:', error);
+      return null;
+    }
+  }
+
+  /**
+   * 기간에 따른 일일 사용량을 조회합니다
+   * @param {string} type - 기간 타입
+   * @returns {Object} 일일 사용량 데이터
+   */
+  getDailyUsageForPeriod(type) {
+    const days = type === 'weekly' ? 7 : type === 'monthly' ? 30 : 1;
+    const result = {};
+    
+    for (let i = 0; i < days; i++) {
+      const date = new Date();
+      date.setDate(date.getDate() - i);
+      const dateStr = date.toISOString().split('T')[0];
+      
+      result[dateStr] = this.data.dailyUsage[dateStr] || {
+        tokens: 0,
+        sessions: 0,
+        commands: 0
+      };
+    }
+    
+    return result;
+  }
+
+  /**
+   * 가장 많이 사용된 명령어를 조회합니다
+   * @param {number} limit - 조회할 명령어 수
+   * @returns {Array<Object>} 상위 명령어 목록
+   */
+  getTopCommands(limit = 10) {
+    try {
+      return Object.entries(this.data.commandStats)
+        .sort((a, b) => b[1].totalTokens - a[1].totalTokens)
+        .slice(0, limit)
+        .map(([command, stats]) => ({
+          command,
+          count: stats.count,
+          totalTokens: stats.totalTokens,
+          avgTokens: stats.avgTokens
+        }));
+    } catch (error) {
+      console.error('상위 명령어 조회 중 오류 발생:', error);
+      return [];
+    }
+  }
+
+  /**
+   * 사용량 트렌드를 계산합니다
+   * @param {string} type - 기간 타입
+   * @returns {Object} 트렌드 데이터
+   */
+  calculateTrends(type) {
+    try {
+      const dailyUsage = this.getDailyUsageForPeriod(type);
+      const values = Object.values(dailyUsage).map(day => day.tokens);
+      
+      if (values.length < 2) {
+        return { trend: 'insufficient_data', change: 0 };
+      }
+      
+      const recent = values.slice(0, Math.floor(values.length / 2));
+      const older = values.slice(Math.floor(values.length / 2));
+      
+      const recentAvg = recent.reduce((sum, val) => sum + val, 0) / recent.length;
+      const olderAvg = older.reduce((sum, val) => sum + val, 0) / older.length;
+      
+      const change = olderAvg > 0 ? ((recentAvg - olderAvg) / olderAvg) * 100 : 0;
+      
+      return {
+        trend: change > 10 ? 'increasing' : change < -10 ? 'decreasing' : 'stable',
+        change: Math.round(change),
+        recentAvg: Math.round(recentAvg),
+        olderAvg: Math.round(olderAvg)
+      };
+    } catch (error) {
+      console.error('트렌드 계산 중 오류 발생:', error);
+      return { trend: 'error', change: 0 };
+    }
+  }
+
+  /**
+   * 기간 정보를 반환합니다
+   * @param {string} type - 기간 타입
+   * @returns {Object} 기간 정보
+   */
+  getPeriod(type) {
+    const now = new Date();
+    const start = new Date(now);
+    
+    switch (type) {
+      case 'weekly':
+        start.setDate(now.getDate() - 7);
+        break;
+      case 'monthly':
+        start.setMonth(now.getMonth() - 1);
+        break;
+      default:
+        start.setDate(now.getDate() - 1);
+    }
+    
+    return {
+      start: start.toISOString().split('T')[0],
+      end: now.toISOString().split('T')[0]
+    };
+  }
+
+  /**
+   * 임계값을 확인합니다
+   * @param {Object} thresholds - 임계값 설정
+   * @returns {Array<Object>} 임계값 위반 목록
+   */
+  checkThresholds(thresholds) {
+    const violations = [];
+    const today = new Date().toISOString().split('T')[0];
+    const todayUsage = this.data.dailyUsage[today] || { tokens: 0, sessions: 0 };
+    
+    try {
+      // 일일 토큰 한도 확인
+      if (thresholds.dailyTokenLimit && todayUsage.tokens > thresholds.dailyTokenLimit) {
+        violations.push({
+          type: 'daily_token_limit',
+          threshold: thresholds.dailyTokenLimit,
+          current: todayUsage.tokens,
+          message: `일일 토큰 한도(${thresholds.dailyTokenLimit})를 초과했습니다: ${todayUsage.tokens}`
+        });
+      }
+      
+      // 일일 세션 한도 확인
+      if (thresholds.dailySessionLimit && todayUsage.sessions > thresholds.dailySessionLimit) {
+        violations.push({
+          type: 'daily_session_limit',
+          threshold: thresholds.dailySessionLimit,
+          current: todayUsage.sessions,
+          message: `일일 세션 한도(${thresholds.dailySessionLimit})를 초과했습니다: ${todayUsage.sessions}`
+        });
+      }
+      
+      // 경고 임계값 확인
+      if (thresholds.warningThreshold) {
+        const warningLimit = thresholds.dailyTokenLimit * (thresholds.warningThreshold / 100);
+        if (todayUsage.tokens > warningLimit) {
+          violations.push({
+            type: 'warning_threshold',
+            threshold: warningLimit,
+            current: todayUsage.tokens,
+            message: `경고 임계값(${Math.round(warningLimit)})을 초과했습니다: ${todayUsage.tokens}`
+          });
+        }
+      }
+    } catch (error) {
+      console.error('임계값 확인 중 오류 발생:', error);
+    }
+    
+    return violations;
+  }
+
+  /**
+   * 저장된 보고서 목록을 조회합니다
+   * @returns {Array<Object>} 보고서 목록
+   */
+  getReportsList() {
+    try {
+      const reports = [];
+      const files = fs.readdirSync(this.reportsDir);
+      
+      for (const file of files) {
+        if (file.endsWith('.json')) {
+          const filePath = path.join(this.reportsDir, file);
+          const stats = fs.statSync(filePath);
+          
+          reports.push({
+            filename: file,
+            path: filePath,
+            size: stats.size,
+            created: stats.birthtime,
+            modified: stats.mtime
+          });
+        }
+      }
+      
+      return reports.sort((a, b) => b.created - a.created);
+    } catch (error) {
+      console.error('보고서 목록 조회 중 오류 발생:', error);
+      return [];
+    }
+  }
+
+  /**
+   * 오래된 보고서를 정리합니다
+   * @param {number} daysToKeep - 보관할 일수
+   */
+  cleanupOldReports(daysToKeep = 30) {
+    try {
+      const cutoffTime = Date.now() - (daysToKeep * 24 * 60 * 60 * 1000);
+      const files = fs.readdirSync(this.reportsDir);
+      let deletedCount = 0;
+      
+      for (const file of files) {
+        if (file.endsWith('.json')) {
+          const filePath = path.join(this.reportsDir, file);
+          const stats = fs.statSync(filePath);
+          
+          if (stats.birthtime.getTime() < cutoffTime) {
+            fs.unlinkSync(filePath);
+            deletedCount++;
+          }
+        }
+      }
+      
+      console.log(`${deletedCount}개의 오래된 보고서를 정리했습니다.`);
+    } catch (error) {
+      console.error('보고서 정리 중 오류 발생:', error);
+    }
+  }
+
+  /**
+   * 모든 데이터를 초기화합니다
+   */
+  resetData() {
+    try {
+      this.data = this.getDefaultData();
+      this.saveData();
+      console.log('토큰 사용량 데이터가 초기화되었습니다.');
+    } catch (error) {
+      console.error('데이터 초기화 중 오류 발생:', error);
+    }
+  }
+}
+
+export default TokenStorage;

package/src/lib/resources/utils/token-tracker.js

@@ -0,0 +1,283 @@
+import fs from 'fs';
+import path from 'path';
+import { TokenCounter } from './token-counter.js';
+
+/**
+ * 세션별 토큰 사용량을 추적하는 클래스
+ */
+export class TokenTracker {
+  constructor(sessionDir = '.aiwf/sessions') {
+    this.sessionDir = sessionDir;
+    this.sessionId = this.generateSessionId();
+    this.counter = new TokenCounter();
+    this.usage = {
+      total: 0,
+      compressed: 0,
+      saved: 0,
+      ratio: 0
+    };
+    this.sessionData = {
+      sessionId: this.sessionId,
+      startTime: Date.now(),
+      totalTokens: 0,
+      commands: [],
+      lastUpdated: Date.now()
+    };
+    
+    this.ensureSessionDirectory();
+    this.loadSession();
+  }
+
+  /**
+   * 세션 ID를 생성합니다
+   * @returns {string} 세션 ID
+   */
+  generateSessionId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substr(2, 9);
+    return `session_${timestamp}_${random}`;
+  }
+
+  /**
+   * 세션 디렉토리를 생성합니다
+   */
+  ensureSessionDirectory() {
+    try {
+      if (!fs.existsSync(this.sessionDir)) {
+        fs.mkdirSync(this.sessionDir, { recursive: true });
+      }
+    } catch (error) {
+      console.error('세션 디렉토리 생성 중 오류 발생:', error);
+    }
+  }
+
+  /**
+   * 세션 데이터를 로드합니다
+   */
+  loadSession() {
+    try {
+      const sessionFile = path.join(this.sessionDir, `${this.sessionId}.json`);
+      
+      if (fs.existsSync(sessionFile)) {
+        const data = JSON.parse(fs.readFileSync(sessionFile, 'utf8'));
+        this.sessionData = { ...this.sessionData, ...data };
+      }
+    } catch (error) {
+      console.error('세션 로드 중 오류 발생:', error);
+    }
+  }
+
+  /**
+   * 세션 데이터를 저장합니다
+   */
+  saveSession() {
+    try {
+      const sessionFile = path.join(this.sessionDir, `${this.sessionId}.json`);
+      this.sessionData.lastUpdated = Date.now();
+      
+      fs.writeFileSync(sessionFile, JSON.stringify(this.sessionData, null, 2));
+    } catch (error) {
+      console.error('세션 저장 중 오류 발생:', error);
+    }
+  }
+
+  /**
+   * 명령어 실행 토큰 사용량을 추적합니다
+   * @param {string} command - 실행된 명령어
+   * @param {string} input - 입력 텍스트
+   * @param {string} output - 출력 텍스트
+   */
+  trackCommand(command, input = '', output = '') {
+    try {
+      const inputTokens = this.counter.countTokens(input);
+      const outputTokens = this.counter.countTokens(output);
+      const totalTokens = inputTokens + outputTokens;
+
+      const commandEntry = {
+        timestamp: Date.now(),
+        command,
+        inputTokens,
+        outputTokens,
+        totalTokens
+      };
+
+      this.sessionData.commands.push(commandEntry);
+      this.sessionData.totalTokens += totalTokens;
+
+      this.saveSession();
+      
+      return commandEntry;
+    } catch (error) {
+      console.error('명령어 토큰 추적 중 오류 발생:', error);
+      return null;
+    }
+  }
+
+  /**
+   * 압축 전후 토큰 수를 기록합니다
+   * @param {number} originalTokens - 원본 토큰 수
+   * @param {number} compressedTokens - 압축된 토큰 수
+   */
+  trackCompression(originalTokens, compressedTokens) {
+    try {
+      this.usage.total = originalTokens;
+      this.usage.compressed = compressedTokens;
+      this.usage.saved = originalTokens - compressedTokens;
+      this.usage.ratio = originalTokens > 0 ? (this.usage.saved / originalTokens) * 100 : 0;
+
+      // 세션 데이터에 압축 정보 추가
+      if (!this.sessionData.compressions) {
+        this.sessionData.compressions = [];
+      }
+
+      this.sessionData.compressions.push({
+        timestamp: Date.now(),
+        originalTokens,
+        compressedTokens,
+        savedTokens: this.usage.saved,
+        ratio: this.usage.ratio
+      });
+
+      this.saveSession();
+    } catch (error) {
+      console.error('압축 토큰 추적 중 오류 발생:', error);
+    }
+  }
+
+  /**
+   * 토큰 사용량 보고서를 생성합니다
+   * @returns {Object} 토큰 사용량 보고서
+   */
+  generateReport() {
+    try {
+      const sessionDuration = Date.now() - this.sessionData.startTime;
+      const avgTokensPerCommand = this.sessionData.commands.length > 0 
+        ? this.sessionData.totalTokens / this.sessionData.commands.length 
+        : 0;
+
+      return {
+        sessionId: this.sessionId,
+        sessionDuration: this.formatDuration(sessionDuration),
+        totalCommands: this.sessionData.commands.length,
+        totalTokens: this.sessionData.totalTokens,
+        avgTokensPerCommand: Math.round(avgTokensPerCommand),
+        compressionStats: this.usage.total > 0 ? {
+          originalTokens: this.usage.total,
+          compressedTokens: this.usage.compressed,
+          savedTokens: this.usage.saved,
+          compressionRatio: this.usage.ratio.toFixed(2) + '%',
+          efficiency: this.usage.ratio >= 50 ? 'High' : this.usage.ratio >= 25 ? 'Medium' : 'Low'
+        } : null,
+        recentCommands: this.sessionData.commands.slice(-5),
+        startTime: new Date(this.sessionData.startTime).toLocaleString(),
+        lastUpdated: new Date(this.sessionData.lastUpdated).toLocaleString()
+      };
+    } catch (error) {
+      console.error('보고서 생성 중 오류 발생:', error);
+      return null;
+    }
+  }
+
+  /**
+   * 시간 간격을 사람이 읽기 쉬운 형태로 변환합니다
+   * @param {number} ms - 밀리초
+   * @returns {string} 포맷된 시간
+   */
+  formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+
+    if (hours > 0) {
+      return `${hours}시간 ${minutes % 60}분`;
+    } else if (minutes > 0) {
+      return `${minutes}분 ${seconds % 60}초`;
+    } else {
+      return `${seconds}초`;
+    }
+  }
+
+  /**
+   * 세션 통계를 조회합니다
+   * @returns {Object} 세션 통계
+   */
+  getSessionStats() {
+    try {
+      return {
+        sessionId: this.sessionId,
+        totalTokens: this.sessionData.totalTokens,
+        commandCount: this.sessionData.commands.length,
+        sessionDuration: Date.now() - this.sessionData.startTime,
+        lastActivity: this.sessionData.lastUpdated
+      };
+    } catch (error) {
+      console.error('세션 통계 조회 중 오류 발생:', error);
+      return null;
+    }
+  }
+
+  /**
+   * 모든 세션 데이터를 조회합니다
+   * @returns {Array<Object>} 세션 목록
+   */
+  getAllSessions() {
+    try {
+      const sessions = [];
+      const files = fs.readdirSync(this.sessionDir);
+      
+      for (const file of files) {
+        if (file.endsWith('.json')) {
+          const sessionData = JSON.parse(
+            fs.readFileSync(path.join(this.sessionDir, file), 'utf8')
+          );
+          sessions.push(sessionData);
+        }
+      }
+      
+      return sessions.sort((a, b) => b.startTime - a.startTime);
+    } catch (error) {
+      console.error('세션 목록 조회 중 오류 발생:', error);
+      return [];
+    }
+  }
+
+  /**
+   * 오래된 세션을 정리합니다
+   * @param {number} daysToKeep - 보관할 일수 (기본: 7일)
+   */
+  cleanupOldSessions(daysToKeep = 7) {
+    try {
+      const cutoffTime = Date.now() - (daysToKeep * 24 * 60 * 60 * 1000);
+      const files = fs.readdirSync(this.sessionDir);
+      let deletedCount = 0;
+      
+      for (const file of files) {
+        if (file.endsWith('.json')) {
+          const filePath = path.join(this.sessionDir, file);
+          const sessionData = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+          
+          if (sessionData.startTime < cutoffTime) {
+            fs.unlinkSync(filePath);
+            deletedCount++;
+          }
+        }
+      }
+      
+      console.log(`${deletedCount}개의 오래된 세션을 정리했습니다.`);
+    } catch (error) {
+      console.error('세션 정리 중 오류 발생:', error);
+    }
+  }
+
+  /**
+   * 리소스를 정리합니다
+   */
+  cleanup() {
+    this.saveSession();
+    if (this.counter) {
+      this.counter.cleanup();
+    }
+  }
+}
+
+export default TokenTracker;