aiwf 0.3.22 → 0.4.0

package/src/lib/backup-manager.js

@@ -1,271 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-import ora from 'ora';
-import chalk from 'chalk';
-import { 
-  TOOL_DIRS, 
-  AIWF_DIRS, 
-  FILES
-} from '../utils/paths.js';
-
-let BACKUP_DIR = null;
-
-/**
- * Generate backup directory name with timestamp
- * @returns {string} Backup directory name
- */
-function getBackupDirName() {
-  const now = new Date();
-  const timestamp = now.toISOString().replace(/[:.]/g, '-').slice(0, -5);
-  return `backup-${timestamp}`;
-}
-
-/**
- * Backup a single file with proper naming convention
- * @param {string} filePath - File to backup
- * @param {string} backupDir - Backup directory path
- * @returns {Promise<string|null>} Backup file path or null
- */
-async function backupFile(filePath, backupDir) {
-  try {
-    const exists = await fs.access(filePath).then(() => true).catch(() => false);
-    if (exists) {
-      await fs.mkdir(backupDir, { recursive: true });
-      const backupPath = `${filePath}.bak`;
-      await fs.copyFile(filePath, backupPath);
-      
-      // Tool-specific backup file naming rules
-      let bakFileName;
-      if (filePath.startsWith(TOOL_DIRS.CLAUDE_COMMANDS + '/')) {
-        // Claude Code command files
-        const relativePath = filePath.substring(TOOL_DIRS.CLAUDE_COMMANDS.length + 1);
-        bakFileName = `claude-commands-aiwf-${relativePath.replace(/\//g, '-')}.bak`;
-      } else if (filePath.startsWith(TOOL_DIRS.GEMINI_PROMPTS + '/')) {
-        // Gemini CLI prompt files
-        const relativePath = filePath.substring(TOOL_DIRS.GEMINI_PROMPTS.length + 1);
-        bakFileName = `gemini-prompts-aiwf-${relativePath.replace(/\//g, '-')}.bak`;
-      } else if (filePath.startsWith(TOOL_DIRS.CURSOR_RULES + '/')) {
-        // Cursor rule files
-        const relativePath = filePath.substring(TOOL_DIRS.CURSOR_RULES.length + 1);
-        bakFileName = `cursor-rules-${relativePath.replace(/\//g, '-')}.bak`;
-      } else if (filePath.startsWith(TOOL_DIRS.WINDSURF_RULES + '/')) {
-        // Windsurf rule files
-        const relativePath = filePath.substring(TOOL_DIRS.WINDSURF_RULES.length + 1);
-        bakFileName = `windsurf-rules-${relativePath.replace(/\//g, '-')}.bak`;
-      } else if (filePath.startsWith(AIWF_DIRS.ROOT + '/')) {
-        // AIWF core files
-        const relativePath = filePath.substring(AIWF_DIRS.ROOT.length + 1);
-        bakFileName = `aiwf-${relativePath.replace(/\//g, '-')}.bak`;
-      } else {
-        // Other files
-        bakFileName = path.basename(filePath) + '.bak';
-      }
-      
-      const destPath = path.join(backupDir, bakFileName);
-      await fs.rename(backupPath, destPath);
-      return destPath;
-    }
-  } catch (error) {
-    // Backup failed, but continue
-  }
-  return null;
-}
-
-/**
- * Backup commands and documentation files
- * @param {Object} messages - Localized messages
- * @param {string} [commandsDir] - Commands directory
- * @returns {Promise<Array<string>>} Array of backed up file paths
- */
-async function backupCommandsAndDocs(messages, commandsDir = TOOL_DIRS.CLAUDE_COMMANDS) {
-  if (!BACKUP_DIR) BACKUP_DIR = getBackupDirName();
-  const spinner = ora(messages.backingUp).start();
-  const backedUpFiles = [];
-  await fs.mkdir(BACKUP_DIR, { recursive: true });
-  
-  try {
-    // Files that will be updated and need backup
-    const filesToBackup = Object.values(FILES.CLAUDE_MD);
-    
-    // Backup CLAUDE.md files
-    for (const file of filesToBackup) {
-      const backupPath = await backupFile(file, BACKUP_DIR);
-      if (backupPath) {
-        backedUpFiles.push(backupPath);
-      }
-    }
-    
-    // Backup all command files
-    const commandsExist = await fs.access(commandsDir).then(() => true).catch(() => false);
-    if (commandsExist) {
-      try {
-        const commandFiles = await fs.readdir(commandsDir);
-        for (const file of commandFiles) {
-          const filePath = path.join(commandsDir, file);
-          const stat = await fs.stat(filePath);
-          if (stat.isFile() && file.endsWith('.md')) {
-            const backupPath = await backupFile(filePath, BACKUP_DIR);
-            if (backupPath) {
-              backedUpFiles.push(backupPath);
-            }
-          }
-        }
-      } catch (error) {
-        // Commands directory might be empty or have issues
-      }
-    }
-    
-    // Backup IDE rule files (Cursor)
-    const cursorRulesExist = await fs.access(TOOL_DIRS.CURSOR_RULES).then(() => true).catch(() => false);
-    if (cursorRulesExist) {
-      try {
-        const cursorFiles = await fs.readdir(TOOL_DIRS.CURSOR_RULES);
-        for (const file of cursorFiles) {
-          if (file.endsWith('.mdc')) {
-            const filePath = path.join(TOOL_DIRS.CURSOR_RULES, file);
-            const backupPath = await backupFile(filePath, BACKUP_DIR);
-            if (backupPath) {
-              backedUpFiles.push(backupPath);
-            }
-          }
-        }
-      } catch (error) {
-        // Cursor rules directory might have issues
-      }
-    }
-    
-    // Backup IDE rule files (Windsurf)
-    const windsurfRulesExist = await fs.access(TOOL_DIRS.WINDSURF_RULES).then(() => true).catch(() => false);
-    if (windsurfRulesExist) {
-      try {
-        const windsurfFiles = await fs.readdir(TOOL_DIRS.WINDSURF_RULES);
-        for (const file of windsurfFiles) {
-          if (file.endsWith('.md')) {
-            const filePath = path.join(TOOL_DIRS.WINDSURF_RULES, file);
-            const backupPath = await backupFile(filePath, BACKUP_DIR);
-            if (backupPath) {
-              backedUpFiles.push(backupPath);
-            }
-          }
-        }
-      } catch (error) {
-        // Windsurf rules directory might have issues
-      }
-    }
-    
-    if (backedUpFiles.length > 0) {
-      spinner.succeed(chalk.green(messages.backupComplete.replace('{count}', backedUpFiles.length)));
-    } else {
-      spinner.succeed(chalk.gray(messages.noFilesToBackup));
-    }
-    return backedUpFiles;
-  } catch (error) {
-    spinner.fail(chalk.red(messages.backupFailed));
-    throw error;
-  }
-}
-
-/**
- * Restore files from backup
- * @param {Object} spinner - Ora spinner instance
- * @param {Object} messages - Localized messages
- * @returns {Promise<void>}
- */
-async function restoreFromBackup(spinner, messages) {
-  if (!BACKUP_DIR) return;
-  
-  try {
-    spinner.text = messages.restoringBackup;
-    
-    // Get all backup files
-    const backupFiles = await fs.readdir(BACKUP_DIR);
-    let restoredCount = 0;
-    
-    for (const bakFile of backupFiles) {
-      if (bakFile.endsWith('.bak')) {
-        const backupPath = path.join(BACKUP_DIR, bakFile);
-        let originalPath;
-        
-        // Determine original path from backup filename
-        if (bakFile.startsWith('claude-commands-aiwf-')) {
-          const relativePath = bakFile
-            .replace('claude-commands-aiwf-', '')
-            .replace('.bak', '')
-            .replace(/-/g, '/');
-          originalPath = path.join(TOOL_DIRS.CLAUDE_COMMANDS, relativePath);
-        } else if (bakFile.startsWith('gemini-prompts-aiwf-')) {
-          const relativePath = bakFile
-            .replace('gemini-prompts-aiwf-', '')
-            .replace('.bak', '')
-            .replace(/-/g, '/');
-          originalPath = path.join(TOOL_DIRS.GEMINI_PROMPTS, relativePath);
-        } else if (bakFile.startsWith('cursor-rules-')) {
-          const relativePath = bakFile
-            .replace('cursor-rules-', '')
-            .replace('.bak', '')
-            .replace(/-/g, '/');
-          originalPath = path.join(TOOL_DIRS.CURSOR_RULES, relativePath);
-        } else if (bakFile.startsWith('windsurf-rules-')) {
-          const relativePath = bakFile
-            .replace('windsurf-rules-', '')
-            .replace('.bak', '')
-            .replace(/-/g, '/');
-          originalPath = path.join(TOOL_DIRS.WINDSURF_RULES, relativePath);
-        } else if (bakFile.startsWith('aiwf-')) {
-          const relativePath = bakFile
-            .replace('aiwf-', '')
-            .replace('.bak', '')
-            .replace(/-/g, '/');
-          originalPath = path.join(AIWF_DIRS.ROOT, relativePath);
-        } else {
-          // Simple filename.ext.bak format
-          originalPath = bakFile.replace('.bak', '');
-        }
-        
-        try {
-          // Ensure directory exists
-          await fs.mkdir(path.dirname(originalPath), { recursive: true });
-          // Copy backup to original location
-          await fs.copyFile(backupPath, originalPath);
-          restoredCount++;
-        } catch (error) {
-          // Individual file restore failed, continue with others
-        }
-      }
-    }
-    
-    // Clean up backup directory
-    await fs.rm(BACKUP_DIR, { recursive: true, force: true });
-    BACKUP_DIR = null;
-    
-    spinner.text = messages.backupRestored.replace('{count}', restoredCount);
-  } catch (error) {
-    spinner.fail(chalk.red(messages.restoreFailed));
-    throw error;
-  }
-}
-
-/**
- * Get current backup directory
- * @returns {string|null} Current backup directory path
- */
-function getCurrentBackupDir() {
-  return BACKUP_DIR;
-}
-
-/**
- * Set backup directory
- * @param {string} dir - Backup directory path
- */
-function setBackupDir(dir) {
-  BACKUP_DIR = dir;
-}
-
-export {
-  getBackupDirName,
-  backupFile,
-  backupCommandsAndDocs,
-  restoreFromBackup,
-  getCurrentBackupDir,
-  setBackupDir
-};

package/src/lib/cache-system.js

@@ -1,332 +0,0 @@
-#!/usr/bin/env node
-
-import fs from 'fs/promises';
-import path from 'path';
-import { createHash } from 'crypto';
-
-/**
- * GitHub API 캐싱 시스템
- * - API 호출 결과를 메모리와 디스크에 캐싱
- * - TTL 기반 캐시 만료 처리
- * - 중복 요청 방지
- */
-class GitHubAPICache {
-    constructor(cacheDir = '.aiwf/cache', ttl = 300000) { // 5분 TTL
-        this.cacheDir = cacheDir;
-        this.ttl = ttl;
-        this.memoryCache = new Map();
-        this.pendingRequests = new Map();
-        this.stats = {
-            hits: 0,
-            misses: 0,
-            requests: 0
-        };
-    }
-
-    async init() {
-        try {
-            await fs.mkdir(this.cacheDir, { recursive: true });
-        } catch (error) {
-            console.warn('Failed to create cache directory:', error.message);
-        }
-    }
-
-    // 캐시 키 생성
-    generateCacheKey(url, headers = {}) {
-        const keyData = JSON.stringify({ url, headers });
-        return createHash('sha256').update(keyData).digest('hex');
-    }
-
-    // 메모리 캐시에서 가져오기
-    getFromMemory(key) {
-        const cached = this.memoryCache.get(key);
-        if (cached && Date.now() - cached.timestamp < this.ttl) {
-            this.stats.hits++;
-            return cached.data;
-        }
-        return null;
-    }
-
-    // 디스크 캐시에서 가져오기
-    async getFromDisk(key) {
-        try {
-            const cachePath = path.join(this.cacheDir, `${key}.json`);
-            const cacheData = await fs.readFile(cachePath, 'utf8');
-            const cached = JSON.parse(cacheData);
-            
-            if (Date.now() - cached.timestamp < this.ttl) {
-                // 메모리 캐시에도 저장
-                this.memoryCache.set(key, cached);
-                this.stats.hits++;
-                return cached.data;
-            } else {
-                // 만료된 캐시 삭제
-                await fs.unlink(cachePath).catch(() => {});
-            }
-        } catch (error) {
-            // 캐시 파일이 없거나 읽기 실패
-        }
-        return null;
-    }
-
-    // 캐시에 저장
-    async saveToCache(key, data) {
-        const cacheEntry = {
-            data,
-            timestamp: Date.now()
-        };
-
-        // 메모리 캐시에 저장
-        this.memoryCache.set(key, cacheEntry);
-
-        // 디스크 캐시에 저장
-        try {
-            const cachePath = path.join(this.cacheDir, `${key}.json`);
-            await fs.writeFile(cachePath, JSON.stringify(cacheEntry, null, 2));
-        } catch (error) {
-            console.warn('Failed to save to disk cache:', error.message);
-        }
-    }
-
-    // 캐시된 데이터 가져오기
-    async get(url, headers = {}) {
-        const key = this.generateCacheKey(url, headers);
-        
-        // 메모리 캐시 확인
-        let cachedData = this.getFromMemory(key);
-        if (cachedData) {
-            return cachedData;
-        }
-
-        // 디스크 캐시 확인
-        cachedData = await this.getFromDisk(key);
-        if (cachedData) {
-            return cachedData;
-        }
-
-        this.stats.misses++;
-        return null;
-    }
-
-    // 캐시에 저장
-    async set(url, data, headers = {}) {
-        const key = this.generateCacheKey(url, headers);
-        await this.saveToCache(key, data);
-    }
-
-    // 중복 요청 방지
-    async getOrFetch(url, fetchFunction, headers = {}) {
-        const key = this.generateCacheKey(url, headers);
-        this.stats.requests++;
-
-        // 캐시에서 확인
-        const cachedData = await this.get(url, headers);
-        if (cachedData) {
-            return cachedData;
-        }
-
-        // 이미 진행 중인 요청이 있는지 확인
-        if (this.pendingRequests.has(key)) {
-            return await this.pendingRequests.get(key);
-        }
-
-        // 새로운 요청 시작
-        const fetchPromise = fetchFunction().then(async (data) => {
-            await this.set(url, data, headers);
-            this.pendingRequests.delete(key);
-            return data;
-        }).catch((error) => {
-            this.pendingRequests.delete(key);
-            throw error;
-        });
-
-        this.pendingRequests.set(key, fetchPromise);
-        return await fetchPromise;
-    }
-
-    // 캐시 통계
-    getStats() {
-        return {
-            ...this.stats,
-            hitRate: this.stats.requests > 0 ? (this.stats.hits / this.stats.requests * 100).toFixed(2) + '%' : '0%',
-            memorySize: this.memoryCache.size,
-            cacheDir: this.cacheDir
-        };
-    }
-
-    // 캐시 정리
-    async cleanup() {
-        const now = Date.now();
-        const expiredKeys = [];
-
-        // 메모리 캐시 정리
-        for (const [key, cached] of this.memoryCache.entries()) {
-            if (now - cached.timestamp >= this.ttl) {
-                expiredKeys.push(key);
-            }
-        }
-
-        expiredKeys.forEach(key => this.memoryCache.delete(key));
-
-        // 디스크 캐시 정리
-        try {
-            const files = await fs.readdir(this.cacheDir);
-            for (const file of files) {
-                if (file.endsWith('.json')) {
-                    const filePath = path.join(this.cacheDir, file);
-                    try {
-                        const stat = await fs.stat(filePath);
-                        if (now - stat.mtime.getTime() >= this.ttl) {
-                            await fs.unlink(filePath);
-                        }
-                    } catch (error) {
-                        // 파일 삭제 실패는 무시
-                    }
-                }
-            }
-        } catch (error) {
-            // 디렉토리 읽기 실패는 무시
-        }
-
-        return {
-            expiredMemoryKeys: expiredKeys.length,
-            message: `Cleaned up ${expiredKeys.length} expired cache entries`
-        };
-    }
-
-    // 전체 캐시 초기화
-    async clear() {
-        this.memoryCache.clear();
-        this.stats = { hits: 0, misses: 0, requests: 0 };
-
-        try {
-            const files = await fs.readdir(this.cacheDir);
-            for (const file of files) {
-                if (file.endsWith('.json')) {
-                    await fs.unlink(path.join(this.cacheDir, file));
-                }
-            }
-        } catch (error) {
-            // 디렉토리 읽기 실패는 무시
-        }
-    }
-}
-
-// 배치 처리를 위한 GitHub API 클라이언트
-class OptimizedGitHubClient {
-    constructor(baseUrl = 'https://api.github.com', cacheOptions = {}) {
-        this.baseUrl = baseUrl;
-        this.cache = new GitHubAPICache(cacheOptions.cacheDir, cacheOptions.ttl);
-        this.rateLimiter = new RateLimiter(60, 60000); // 60 requests per minute
-        this.batchQueue = [];
-        this.batchTimeout = null;
-    }
-
-    async init() {
-        await this.cache.init();
-    }
-
-    // 캐시된 HTTP 요청
-    async cachedFetch(url, options = {}) {
-        const headers = { 'User-Agent': 'aiwf', ...options.headers };
-        
-        return await this.cache.getOrFetch(url, async () => {
-            // Rate limiting
-            await this.rateLimiter.waitForNext();
-            
-            const response = await fetch(url, { ...options, headers });
-            if (!response.ok) {
-                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-            }
-            
-            return await response.json();
-        }, headers);
-    }
-
-    // 배치 요청 처리
-    async batchRequest(urls, options = {}) {
-        const results = [];
-        const batchSize = options.batchSize || 5;
-        
-        for (let i = 0; i < urls.length; i += batchSize) {
-            const batch = urls.slice(i, i + batchSize);
-            const batchPromises = batch.map(url => this.cachedFetch(url, options));
-            
-            try {
-                const batchResults = await Promise.allSettled(batchPromises);
-                results.push(...batchResults);
-            } catch (error) {
-                console.error('Batch request failed:', error);
-                results.push(...batch.map(() => ({ status: 'rejected', reason: error })));
-            }
-        }
-        
-        return results;
-    }
-
-    // 디렉토리 구조 가져오기 (캐시 적용)
-    async getDirectoryStructure(repoPath, dirPath = '') {
-        const url = `${this.baseUrl}/repos/${repoPath}/contents/${dirPath}`;
-        return await this.cachedFetch(url);
-    }
-
-    // 파일 내용 가져오기 (캐시 적용)
-    async getFileContent(repoPath, filePath) {
-        const url = `${this.baseUrl}/repos/${repoPath}/contents/${filePath}`;
-        return await this.cachedFetch(url);
-    }
-
-    // 통계 정보
-    getStats() {
-        return {
-            cache: this.cache.getStats(),
-            rateLimit: this.rateLimiter.getStats()
-        };
-    }
-
-    // 캐시 정리
-    async cleanup() {
-        return await this.cache.cleanup();
-    }
-}
-
-// Rate Limiter 클래스
-class RateLimiter {
-    constructor(maxRequests, timeWindow) {
-        this.maxRequests = maxRequests;
-        this.timeWindow = timeWindow;
-        this.requests = [];
-        this.stats = { totalRequests: 0, throttledRequests: 0 };
-    }
-
-    async waitForNext() {
-        const now = Date.now();
-        
-        // 시간 윈도우를 벗어난 요청 제거
-        this.requests = this.requests.filter(time => now - time < this.timeWindow);
-        
-        if (this.requests.length >= this.maxRequests) {
-            const oldestRequest = Math.min(...this.requests);
-            const waitTime = this.timeWindow - (now - oldestRequest);
-            
-            if (waitTime > 0) {
-                this.stats.throttledRequests++;
-                await new Promise(resolve => setTimeout(resolve, waitTime));
-            }
-        }
-        
-        this.requests.push(now);
-        this.stats.totalRequests++;
-    }
-
-    getStats() {
-        return {
-            ...this.stats,
-            currentRequests: this.requests.length,
-            maxRequests: this.maxRequests,
-            timeWindow: this.timeWindow
-        };
-    }
-}
-
-export { GitHubAPICache, OptimizedGitHubClient, RateLimiter };