aiwf 0.3.8 → 0.3.13

package/claude-code/aiwf/en/utils/token-storage.js

@@ -1,433 +0,0 @@
-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/claude-code/aiwf/en/utils/token-tracker.js

@@ -1,283 +0,0 @@
-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;