aiwf 0.3.0 → 0.3.2

package/index.js

@@ -10,13 +10,23 @@ import { fileURLToPath } from 'url';
 import https from 'https';
 import { createWriteStream } from 'fs';
 import { pipeline } from 'stream/promises';
+import {
+    detectLanguage,
+    loadUserLanguageConfig,
+    saveUserLanguageConfig,
+    getInstallationLanguagePath,
+    SUPPORTED_LANGUAGES,
+    DEFAULT_LANGUAGE
+} from './language-utils.js';
+import AIToolCommand from './src/commands/ai-tool.js';
+import { CacheCLI } from './lib/cache-cli.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 const program = new Command();
 
 const GITHUB_API_URL = 'https://api.github.com/repos/moonklabs/aiwf';
-const GITHUB_RAW_URL = 'https://raw.githubusercontent.com/moonklabs/aiwf/master';
+const GITHUB_RAW_URL = 'https://raw.githubusercontent.com/moonklabs/aiwf/main';
 const GITHUB_CONTENT_PREFIX = 'claude-code/aiwf';
 
 async function fetchGitHubContent(url) {
@@ -99,15 +109,34 @@ async function backupFile(filePath, backupDir) {
             await fs.mkdir(backupDir, { recursive: true });
             const backupPath = `${filePath}.bak`;
             await fs.copyFile(filePath, backupPath);
-            // 상대경로 보존: .claude/commands/aiwf/foo.md -> backupDir/claude-commands-aiwf-foo.md.bak
+            
+            // 도구별 백업 파일 명명 규칙 개선
             let bakFileName;
-            if (filePath.startsWith(COMMANDS_DIR + '/')) {
-                bakFileName = filePath.replace(/\//g, '-').replace(/^\./, '') + '.bak';
+            if (filePath.startsWith('.claude/commands/aiwf/')) {
+                // Claude Code 명령어 파일
+                const relativePath = filePath.substring('.claude/commands/aiwf/'.length);
+                bakFileName = `claude-commands-aiwf-${relativePath.replace(/\//g, '-')}.bak`;
+            } else if (filePath.startsWith('.gemini/prompts/aiwf/')) {
+                // Gemini CLI 프롬프트 파일
+                const relativePath = filePath.substring('.gemini/prompts/aiwf/'.length);
+                bakFileName = `gemini-prompts-aiwf-${relativePath.replace(/\//g, '-')}.bak`;
+            } else if (filePath.startsWith('.cursor/rules/')) {
+                // Cursor 규칙 파일
+                const relativePath = filePath.substring('.cursor/rules/'.length);
+                bakFileName = `cursor-rules-${relativePath.replace(/\//g, '-')}.bak`;
+            } else if (filePath.startsWith('.windsurf/rules/')) {
+                // Windsurf 규칙 파일
+                const relativePath = filePath.substring('.windsurf/rules/'.length);
+                bakFileName = `windsurf-rules-${relativePath.replace(/\//g, '-')}.bak`;
             } else if (filePath.startsWith('.aiwf/')) {
-                bakFileName = filePath.replace(/\//g, '-').replace(/^\./, '') + '.bak';
+                // AIWF 핵심 파일
+                const relativePath = filePath.substring('.aiwf/'.length);
+                bakFileName = `aiwf-${relativePath.replace(/\//g, '-')}.bak`;
             } else {
+                // 기타 파일
                 bakFileName = path.basename(filePath) + '.bak';
             }
+            
             const destPath = path.join(backupDir, bakFileName);
             await fs.rename(backupPath, destPath);
             return destPath;
@@ -131,6 +160,7 @@ async function backupCommandsAndDocs(msg) {
             '.aiwf/03_SPRINTS/CLAUDE.md',
             '.aiwf/04_GENERAL_TASKS/CLAUDE.md'
         ];
+        
         // Backup CLAUDE.md files
         for (const file of filesToBackup) {
             const backupPath = await backupFile(file, BACKUP_DIR);
@@ -138,6 +168,7 @@ async function backupCommandsAndDocs(msg) {
                 backedUpFiles.push(backupPath);
             }
         }
+        
         // Backup all command files
         const commandsExist = await fs.access(COMMANDS_DIR).then(() => true).catch(() => false);
         if (commandsExist) {
@@ -157,6 +188,45 @@ async function backupCommandsAndDocs(msg) {
                 // Commands directory might be empty or have issues
             }
         }
+        
+        // Backup IDE rule files (Cursor)
+        const cursorRulesExist = await fs.access('.cursor/rules').then(() => true).catch(() => false);
+        if (cursorRulesExist) {
+            try {
+                const cursorFiles = await fs.readdir('.cursor/rules');
+                for (const file of cursorFiles) {
+                    if (file.endsWith('.mdc')) {
+                        const filePath = path.join('.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('.windsurf/rules').then(() => true).catch(() => false);
+        if (windsurfRulesExist) {
+            try {
+                const windsurfFiles = await fs.readdir('.windsurf/rules');
+                for (const file of windsurfFiles) {
+                    if (file.endsWith('.md')) {
+                        const filePath = path.join('.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(msg.backupComplete.replace('{count}', backedUpFiles.length)));
         } else {
@@ -310,24 +380,1128 @@ const messages = {
     }
 };
 
+// =============================================================================
+// INSTALLATION VALIDATION SYSTEM
+// =============================================================================
+
+// 각 도구별 필수 파일 목록 정의
+const ESSENTIAL_FILES = {
+    claudeCode: {
+        baseDir: '.claude/commands/aiwf',
+        requiredFiles: [
+            'aiwf_initialize.md',
+            'aiwf_do_task.md',
+            'aiwf_commit.md',
+            'aiwf_create_sprint_tasks.md',
+            'aiwf_code_review.md'
+        ],
+        minFileCount: 5,
+        description: 'Claude Code Commands'
+    },
+    geminiCLI: {
+        baseDir: '.gemini/prompts/aiwf',
+        requiredFiles: [
+            'README.md'
+        ],
+        minFileCount: 1,
+        description: 'Gemini-CLI Prompts'
+    },
+    cursor: {
+        baseDir: '.cursor/rules',
+        requiredFiles: [],
+        minFileCount: 2,
+        fileExtension: '.mdc',
+        description: 'Cursor IDE Rules'
+    },
+    windsurf: {
+        baseDir: '.windsurf/rules',
+        requiredFiles: [],
+        minFileCount: 2,
+        fileExtension: '.md',
+        description: 'Windsurf IDE Rules'
+    },
+    aiwf: {
+        baseDir: '.aiwf',
+        requiredFiles: [
+            'CLAUDE.md',
+            '00_PROJECT_MANIFEST.md'
+        ],
+        minFileCount: 2,
+        description: 'AIWF Core Structure'
+    }
+};
+
+// 범용 검증 함수 (모든 도구에서 사용)
+async function validateToolInstallation(config) {
+    const results = {
+        success: true,
+        description: config.description,
+        baseDir: config.baseDir,
+        checks: {
+            directoryExists: false,
+            fileCount: 0,
+            requiredFiles: [],
+            totalSize: 0,
+            issues: []
+        }
+    };
+
+    try {
+        // 1. 디렉토리 존재 확인
+        await fs.access(config.baseDir);
+        const dirStat = await fs.stat(config.baseDir);
+        if (dirStat.isDirectory()) {
+            results.checks.directoryExists = true;
+        } else {
+            results.checks.issues.push(`${config.baseDir} is not a directory`);
+            results.success = false;
+            return results;
+        }
+
+        // 2. 파일 목록 가져오기
+        const actualFiles = await fs.readdir(config.baseDir);
+        results.checks.fileCount = actualFiles.length;
+
+        // 3. 필수 파일 존재 확인
+        for (const requiredFile of config.requiredFiles || []) {
+            const filePath = path.join(config.baseDir, requiredFile);
+            const fileCheck = {
+                file: requiredFile,
+                exists: false,
+                size: 0,
+                valid: false
+            };
+
+            if (actualFiles.includes(requiredFile)) {
+                fileCheck.exists = true;
+                try {
+                    const stats = await fs.stat(filePath);
+                    fileCheck.size = stats.size;
+                    results.checks.totalSize += stats.size;
+                    
+                    // 파일 크기 검증 (최소 10바이트)
+                    if (stats.size < 10) {
+                        results.checks.issues.push(`File ${requiredFile} is too small (${stats.size} bytes)`);
+                        results.success = false;
+                    } else {
+                        fileCheck.valid = true;
+                    }
+                } catch (error) {
+                    results.checks.issues.push(`Cannot read stats for ${requiredFile}: ${error.message}`);
+                    results.success = false;
+                }
+            } else {
+                results.checks.issues.push(`Required file ${requiredFile} is missing`);
+                results.success = false;
+            }
+
+            results.checks.requiredFiles.push(fileCheck);
+        }
+
+        // 4. 파일 확장자 기반 검증 (Cursor/Windsurf)
+        if (config.fileExtension) {
+            const matchingFiles = actualFiles.filter(f => f.endsWith(config.fileExtension));
+            if (matchingFiles.length < config.minFileCount) {
+                results.checks.issues.push(`Expected at least ${config.minFileCount} ${config.fileExtension} files, found ${matchingFiles.length}`);
+                results.success = false;
+            }
+
+            // 확장자별 파일 크기 검증
+            for (const file of matchingFiles) {
+                const filePath = path.join(config.baseDir, file);
+                try {
+                    const stats = await fs.stat(filePath);
+                    results.checks.totalSize += stats.size;
+                    
+                    if (stats.size < 50) { // Rules 파일은 최소 50바이트
+                        results.checks.issues.push(`Rules file ${file} is too small (${stats.size} bytes)`);
+                        results.success = false;
+                    }
+                } catch (error) {
+                    results.checks.issues.push(`Cannot read ${file}: ${error.message}`);
+                    results.success = false;
+                }
+            }
+        }
+
+        // 5. 최소 파일 개수 검증
+        if (results.checks.fileCount < config.minFileCount) {
+            results.checks.issues.push(`Expected at least ${config.minFileCount} files, found ${results.checks.fileCount}`);
+            results.success = false;
+        }
+
+    } catch (error) {
+        results.success = false;
+        results.checks.issues.push(`Validation error: ${error.message}`);
+    }
+
+    return results;
+}
+
+// 개별 도구 검증 함수들
+async function validateClaudeInstall() {
+    return await validateToolInstallation(ESSENTIAL_FILES.claudeCode);
+}
+
+async function validateGeminiInstall() {
+    return await validateToolInstallation(ESSENTIAL_FILES.geminiCLI);
+}
+
+async function validateCursorInstall() {
+    return await validateToolInstallation(ESSENTIAL_FILES.cursor);
+}
+
+async function validateWindsurfInstall() {
+    return await validateToolInstallation(ESSENTIAL_FILES.windsurf);
+}
+
+async function validateAIWFCore() {
+    return await validateToolInstallation(ESSENTIAL_FILES.aiwf);
+}
+
+// Legacy detailed validation (for backward compatibility)
+async function validateInstallationDetailed() {
+    const validationResults = {
+        overall: {
+            success: true,
+            toolsChecked: 0,
+            toolsPassed: 0,
+            toolsFailed: 0,
+            totalIssues: 0
+        },
+        tools: {}
+    };
+
+    // AIWF 코어는 항상 검증
+    const aiwfResult = await validateAIWFCore();
+    validationResults.tools.aiwf = aiwfResult;
+    validationResults.overall.toolsChecked++;
+    
+    if (aiwfResult.success) {
+        validationResults.overall.toolsPassed++;
+    } else {
+        validationResults.overall.toolsFailed++;
+        validationResults.overall.success = false;
+        validationResults.overall.totalIssues += aiwfResult.checks.issues.length;
+    }
+
+    // 모든 도구 검증 (이 간단한 버전에서는 항상 모든 도구 설치)
+    const toolValidators = {
+        claudeCode: validateClaudeInstall,
+        geminiCLI: validateGeminiInstall,
+        cursor: validateCursorInstall,
+        windsurf: validateWindsurfInstall
+    };
+
+    for (const [toolName, validator] of Object.entries(toolValidators)) {
+        const result = await validator();
+        validationResults.tools[toolName] = result;
+        validationResults.overall.toolsChecked++;
+        
+        if (result.success) {
+            validationResults.overall.toolsPassed++;
+        } else {
+            validationResults.overall.toolsFailed++;
+            validationResults.overall.success = false;
+            validationResults.overall.totalIssues += result.checks.issues.length;
+        }
+    }
+
+    return validationResults;
+}
+
+// 향상된 설치 검증 함수 (선택적 도구 지원)
+async function validateInstallationEnhanced(selectedTools = null, language = 'en') {
+    const validationResults = {
+        overall: {
+            success: true,
+            toolsChecked: 0,
+            toolsPassed: 0,
+            toolsFailed: 0,
+            totalIssues: 0
+        },
+        tools: {}
+    };
+
+    // AIWF 코어는 항상 검증
+    const aiwfResult = await validateAIWFCore();
+    validationResults.tools.aiwf = aiwfResult;
+    validationResults.overall.toolsChecked++;
+    
+    if (aiwfResult.success) {
+        validationResults.overall.toolsPassed++;
+    } else {
+        validationResults.overall.toolsFailed++;
+        validationResults.overall.success = false;
+        validationResults.overall.totalIssues += aiwfResult.checks.issues.length;
+    }
+
+    // 도구 목록 결정 (선택된 도구 또는 모든 도구)
+    const toolsToValidate = selectedTools || ['claudeCode', 'geminiCLI', 'cursor', 'windsurf'];
+    
+    const toolValidators = {
+        claudeCode: validateClaudeInstall,
+        geminiCLI: validateGeminiInstall,
+        cursor: validateCursorInstall,
+        windsurf: validateWindsurfInstall
+    };
+
+    for (const toolName of toolsToValidate) {
+        if (toolValidators[toolName]) {
+            const result = await toolValidators[toolName]();
+            validationResults.tools[toolName] = result;
+            validationResults.overall.toolsChecked++;
+            
+            if (result.success) {
+                validationResults.overall.toolsPassed++;
+            } else {
+                validationResults.overall.toolsFailed++;
+                validationResults.overall.success = false;
+                validationResults.overall.totalIssues += result.checks.issues.length;
+            }
+        }
+    }
+
+    return validationResults;
+}
+
+// Display validation results for specification-compliant format
+function displaySpecCompliantValidationResults(validationResults, language) {
+    const msg = messages[language];
+    
+    console.log(chalk.blue('\n=== Installation Validation Results ==='));
+    
+    // Success summary
+    if (validationResults.success.length > 0) {
+        console.log(chalk.green(`\n✅ Successfully Validated Tools (${validationResults.success.length}):`));
+        validationResults.success.forEach(tool => {
+            console.log(chalk.green(`   ✓ ${tool}`));
+        });
+    }
+    
+    // Failed summary
+    if (validationResults.failed.length > 0) {
+        console.log(chalk.red(`\n❌ Failed Validations (${validationResults.failed.length}):`));
+        validationResults.failed.forEach(({tool, reason}) => {
+            console.log(chalk.red(`   ✗ ${tool}: ${reason}`));
+        });
+    }
+    
+    // Warnings summary  
+    if (validationResults.warnings.length > 0) {
+        console.log(chalk.yellow(`\n⚠️ Warnings (${validationResults.warnings.length}):`));
+        validationResults.warnings.forEach(warning => {
+            console.log(chalk.yellow(`   ⚠ ${warning}`));
+        });
+    }
+    
+    // Overall status
+    const isSuccess = validationResults.failed.length === 0;
+    const statusIcon = isSuccess ? '✅' : '❌';
+    const statusColor = isSuccess ? chalk.green : chalk.red;
+    const statusText = isSuccess ? 'PASSED' : 'FAILED';
+    
+    console.log(statusColor(`\n${statusIcon} Overall Validation: ${statusText}`));
+    
+    if (isSuccess) {
+        console.log(chalk.green('🎉 All selected tools are properly installed and validated!'));
+    } else {
+        console.log(chalk.yellow('⚠️ Some installations failed. See details above.'));
+    }
+}
+
+// Enhanced validation function with simplified interface for T05_S02
+async function validateInstallation(selectedTools, language) {
+    const results = {
+        success: [],
+        failed: [],
+        warnings: []
+    };
+    
+    // Always validate common files (AIWF core)
+    const commonValid = await validateCommonFiles();
+    if (!commonValid.success) {
+        results.failed.push({ tool: 'aiwf', reason: commonValid.reason });
+    } else {
+        results.success.push('aiwf');
+    }
+    
+    // Validate selected tools
+    if (selectedTools && selectedTools.length > 0) {
+        for (const tool of selectedTools) {
+            const validation = await validateTool(tool);
+            if (validation.success) {
+                results.success.push(tool);
+            } else {
+                results.failed.push({ tool, reason: validation.reason });
+            }
+        }
+    } else {
+        // Default: validate all tools if no selection provided
+        const allTools = ['claudeCode', 'geminiCLI', 'cursor', 'windsurf'];
+        for (const tool of allTools) {
+            const validation = await validateTool(tool);
+            if (validation.success) {
+                results.success.push(tool);
+            } else {
+                results.failed.push({ tool, reason: validation.reason });
+            }
+        }
+    }
+    
+    return results;
+}
+
+// Helper function to validate common/core files
+async function validateCommonFiles() {
+    try {
+        const requiredFiles = [
+            '.aiwf/CLAUDE.md',
+            '.aiwf/00_PROJECT_MANIFEST.md'
+        ];
+        
+        for (const file of requiredFiles) {
+            const exists = await fs.access(file).then(() => true).catch(() => false);
+            if (!exists) {
+                return { success: false, reason: `Missing core file: ${file}` };
+            }
+        }
+        
+        return { success: true };
+    } catch (error) {
+        return { success: false, reason: `Core validation error: ${error.message}` };
+    }
+}
+
+// Helper function to validate specific tools with simplified interface
+async function validateTool(tool) {
+    switch (tool) {
+        case 'claudeCode':
+        case 'claude-code':
+            return validateClaudeCode();
+        case 'geminiCLI':
+        case 'gemini-cli':
+            return validateGeminiCLI();
+        case 'cursor':
+            return validateCursorTool();
+        case 'windsurf':
+            return validateWindsurfTool();
+        case 'aiwf':
+            return validateCommonFiles();
+        default:
+            return { success: false, reason: `Unknown tool: ${tool}` };
+    }
+}
+
+// Simplified tool validation functions
+async function validateClaudeCode() {
+    try {
+        const requiredFiles = [
+            '.claude/commands/aiwf/aiwf_initialize.md',
+            '.claude/commands/aiwf/aiwf_do_task.md',
+            '.claude/commands/aiwf/aiwf_commit.md',
+            '.claude/commands/aiwf/aiwf_code_review.md'
+        ];
+        
+        for (const file of requiredFiles) {
+            const exists = await fs.access(file).then(() => true).catch(() => false);
+            if (!exists) {
+                return { success: false, reason: `Missing file: ${file}` };
+            }
+        }
+        
+        return { success: true };
+    } catch (error) {
+        return { success: false, reason: `Claude Code validation error: ${error.message}` };
+    }
+}
+
+async function validateGeminiCLI() {
+    try {
+        // Check if .gemini/prompts/aiwf directory exists
+        const dirExists = await fs.access('.gemini/prompts/aiwf').then(() => true).catch(() => false);
+        if (!dirExists) {
+            return { success: false, reason: 'Missing Gemini-CLI prompts directory: .gemini/prompts/aiwf' };
+        }
+        
+        return { success: true };
+    } catch (error) {
+        return { success: false, reason: `Gemini-CLI validation error: ${error.message}` };
+    }
+}
+
+async function validateCursorTool() {
+    try {
+        const dirExists = await fs.access('.cursor/rules').then(() => true).catch(() => false);
+        if (!dirExists) {
+            return { success: false, reason: 'Missing Cursor rules directory: .cursor/rules' };
+        }
+        
+        return { success: true };
+    } catch (error) {
+        return { success: false, reason: `Cursor validation error: ${error.message}` };
+    }
+}
+
+async function validateWindsurfTool() {
+    try {
+        const dirExists = await fs.access('.windsurf/rules').then(() => true).catch(() => false);
+        if (!dirExists) {
+            return { success: false, reason: 'Missing Windsurf rules directory: .windsurf/rules' };
+        }
+        
+        return { success: true };
+    } catch (error) {
+        return { success: false, reason: `Windsurf validation error: ${error.message}` };
+    }
+}
+
+// Enhanced rollback function for T05_S02
+async function rollbackToolEnhanced(tool, backupDir, language = 'ko') {
+    const spinner = ora(`Rolling back ${tool}...`).start();
+    
+    try {
+        // Get tool directory mapping
+        const toolDir = getToolDirectory(tool);
+        if (!toolDir) {
+            spinner.fail(`Unknown tool: ${tool}`);
+            return false;
+        }
+        
+        // Remove installed directory
+        try {
+            await fs.access(toolDir);
+            await fs.rm(toolDir, { recursive: true, force: true });
+            spinner.text = `Removed ${toolDir}`;
+        } catch (error) {
+            // Directory doesn't exist, skip
+        }
+        
+        // Restore from backup if available
+        if (backupDir) {
+            const backupFiles = await getBackupFilesForTool(tool, backupDir);
+            for (const backup of backupFiles) {
+                await restoreBackupFile(backup);
+                spinner.text = `Restored ${backup.originalPath}`;
+            }
+        }
+        
+        spinner.succeed(`${tool} rolled back successfully`);
+        return true;
+    } catch (error) {
+        spinner.fail(`Failed to rollback ${tool}: ${error.message}`);
+        return false;
+    }
+}
+
+// Helper function to get tool directories
+function getToolDirectory(tool) {
+    const toolDirs = {
+        claudeCode: '.claude/commands/aiwf',
+        'claude-code': '.claude/commands/aiwf',
+        geminiCLI: '.gemini/prompts/aiwf',
+        'gemini-cli': '.gemini/prompts/aiwf',
+        cursor: '.cursor/rules',
+        windsurf: '.windsurf/rules',
+        aiwf: '.aiwf'
+    };
+    
+    return toolDirs[tool] || null;
+}
+
+// Helper function to restore backup file
+async function restoreBackupFile(backup) {
+    try {
+        // Ensure target directory exists
+        const targetDir = path.dirname(backup.originalPath);
+        await fs.mkdir(targetDir, { recursive: true });
+        
+        // Copy backup file to original location
+        await fs.copyFile(backup.backupFile, backup.originalPath);
+    } catch (error) {
+        throw new Error(`Failed to restore ${backup.originalPath}: ${error.message}`);
+    }
+}
+
+// Enhanced installation report generation function for T05_S02
+function generateInstallationReportEnhanced(results, language) {
+    const msg = messages[language];
+    
+    console.log('\n' + chalk.bold(language === 'ko' ? '📋 설치 리포트' : '📋 Installation Report'));
+    console.log('─'.repeat(50));
+    
+    if (results.success.length > 0) {
+        console.log(chalk.green(language === 'ko' ? '✅ 성공적으로 설치된 도구:' : '✅ Successfully Installed Tools:'));
+        results.success.forEach(tool => {
+            console.log(chalk.green(`  ✓ ${getToolName(tool, language)}`));
+        });
+    }
+    
+    if (results.failed.length > 0) {
+        console.log(chalk.red(language === 'ko' ? '\n❌ 설치 실패한 도구:' : '\n❌ Failed to Install:'));
+        results.failed.forEach(({ tool, reason }) => {
+            console.log(chalk.red(`  ✗ ${getToolName(tool, language)}: ${reason}`));
+        });
+    }
+    
+    if (results.warnings.length > 0) {
+        console.log(chalk.yellow(language === 'ko' ? '\n⚠️ 경고:' : '\n⚠️ Warnings:'));
+        results.warnings.forEach(warning => {
+            console.log(chalk.yellow(`  ⚠ ${warning}`));
+        });
+    }
+    
+    console.log('─'.repeat(50));
+}
+
+// Helper function to get localized tool names
+function getToolName(tool, language) {
+    const toolNames = {
+        ko: {
+            aiwf: 'AIWF 코어 구조',
+            claudeCode: 'Claude Code 명령어',
+            'claude-code': 'Claude Code 명령어',
+            geminiCLI: 'Gemini-CLI 프롬프트',
+            'gemini-cli': 'Gemini-CLI 프롬프트',
+            cursor: 'Cursor IDE 규칙',
+            windsurf: 'Windsurf IDE 규칙'
+        },
+        en: {
+            aiwf: 'AIWF Core Structure',
+            claudeCode: 'Claude Code Commands',
+            'claude-code': 'Claude Code Commands',
+            geminiCLI: 'Gemini-CLI Prompts',
+            'gemini-cli': 'Gemini-CLI Prompts',
+            cursor: 'Cursor IDE Rules',
+            windsurf: 'Windsurf IDE Rules'
+        }
+    };
+    
+    return toolNames[language]?.[tool] || tool;
+}
+
+// Enhanced installation flow with validation and rollback for T05_S02
+async function performInstallationStepEnhanced(language, selectedTools) {
+    try {
+        // ... installation performed by existing code ...
+        // This function would be integrated into the main installation flow
+        
+        // After installation, perform validation
+        const validation = await validateInstallation(selectedTools, language);
+        
+        // Handle failed tools with rollback
+        if (validation.failed.length > 0) {
+            console.log(chalk.yellow('\n⚠️ Some installations failed. Initiating rollback...'));
+            
+            for (const { tool } of validation.failed) {
+                console.log(chalk.yellow(`Rolling back ${tool}...`));
+                await rollbackToolEnhanced(tool, BACKUP_DIR, language);
+            }
+        }
+        
+        // Generate installation report
+        generateInstallationReportEnhanced(validation, language);
+        
+        // Throw error if complete failure
+        if (validation.success.length === 0) {
+            const errorMsg = language === 'ko' ? 
+                '모든 설치가 실패했습니다.' : 
+                'All installations failed.';
+            throw new Error(errorMsg);
+        }
+        
+        return validation;
+    } catch (error) {
+        console.error(chalk.red(`Installation step failed: ${error.message}`));
+        throw error;
+    }
+}
+
+// 설치 리포트 생성 함수 (통합된 버전)
+function generateInstallationReport(validationResults, language, installationType = 'install') {
+    const msg = messages[language];
+    
+    // 상단 헤더
+    console.log(chalk.blue.bold('\n' + '='.repeat(60)));
+    console.log(chalk.blue.bold(
+        language === 'ko' ? 
+        '🔍 AIWF 설치 검증 및 리포트' : 
+        '🔍 AIWF Installation Validation & Report'
+    ));
+    console.log(chalk.blue.bold('='.repeat(60)));
+    
+    // 설치 유형 표시
+    const installTypeText = {
+        install: language === 'ko' ? '새 설치' : 'Fresh Installation',
+        update: language === 'ko' ? '업데이트' : 'Update',
+        reinstall: language === 'ko' ? '재설치' : 'Reinstallation'
+    };
+    console.log(chalk.gray(`설치 유형 / Installation Type: ${installTypeText[installationType] || installTypeText.install}`));
+    console.log(chalk.gray(`검증 시간 / Validation Time: ${new Date().toLocaleString()}`));
+    
+    // 전체 요약
+    const { overall } = validationResults;
+    const statusIcon = overall.success ? '✅' : '❌';
+    const statusColor = overall.success ? chalk.green : chalk.red;
+    
+    console.log(statusColor(`\n${statusIcon} 전체 상태 / Overall Status: ${overall.success ? 'PASSED' : 'FAILED'}`));
+    console.log(chalk.gray(`   검증한 도구 / Tools Checked: ${overall.toolsChecked}`));
+    console.log(chalk.gray(`   성공한 도구 / Tools Passed: ${overall.toolsPassed}`));
+    
+    if (overall.toolsFailed > 0) {
+        console.log(chalk.red(`   실패한 도구 / Tools Failed: ${overall.toolsFailed}`));
+        console.log(chalk.red(`   총 이슈 수 / Total Issues: ${overall.totalIssues}`));
+    }
+
+    // 개별 도구 결과
+    console.log(chalk.blue('\n=== 개별 도구 결과 / Individual Tool Results ==='));
+    
+    for (const [toolName, result] of Object.entries(validationResults.tools)) {
+        const toolIcon = result.success ? '✅' : '❌';
+        const toolColor = result.success ? chalk.green : chalk.red;
+        
+        console.log(toolColor(`\n${toolIcon} ${result.description} (${toolName})`));
+        console.log(chalk.gray(`   디렉토리 / Directory: ${result.baseDir}`));
+        console.log(chalk.gray(`   파일 수 / Files Found: ${result.checks.fileCount}`));
+        console.log(chalk.gray(`   총 크기 / Total Size: ${(result.checks.totalSize / 1024).toFixed(2)} KB`));
+        
+        if (result.checks.issues.length > 0) {
+            console.log(chalk.red(`   이슈 / Issues:`));
+            for (const issue of result.checks.issues) {
+                console.log(chalk.red(`     • ${issue}`));
+            }
+        }
+        
+        if (result.checks.requiredFiles.length > 0) {
+            console.log(chalk.gray(`   필수 파일 / Required Files:`));
+            for (const fileCheck of result.checks.requiredFiles) {
+                const fileIcon = fileCheck.valid ? '✅' : '❌';
+                const fileColor = fileCheck.valid ? chalk.gray : chalk.red;
+                console.log(fileColor(`     ${fileIcon} ${fileCheck.file} (${(fileCheck.size / 1024).toFixed(2)} KB)`));
+            }
+        }
+    }
+    
+    // 권장사항 섹션
+    console.log(chalk.blue('\n=== 권장사항 / Recommendations ==='));
+    if (overall.success) {
+        console.log(chalk.green('🎉 모든 도구가 올바르게 설치되어 검증되었습니다!'));
+        console.log(chalk.green('🎉 All tools are properly installed and validated!'));
+        console.log(chalk.blue('\n다음 단계 / Next Steps:'));
+        console.log(chalk.white('   1. Claude Code에서 프로젝트를 열어보세요'));
+        console.log(chalk.white('   2. /project:aiwf:initialize 명령어로 프로젝트를 초기화하세요'));
+        console.log(chalk.white('   3. 프로젝트 관리를 시작하세요!'));
+    } else {
+        console.log(chalk.yellow('⚠️  일부 이슈가 발견되었습니다. 위의 세부사항을 확인하세요.'));
+        console.log(chalk.yellow('⚠️  Some issues were found. See details above.'));
+        
+        // 실패한 도구별 해결 방안 제시
+        const failedTools = Object.entries(validationResults.tools)
+            .filter(([_, result]) => !result.success)
+            .map(([tool, _]) => tool);
+            
+        if (failedTools.length > 0) {
+            console.log(chalk.blue('\n해결 방안 / Solutions:'));
+            console.log(chalk.yellow('   • 전체 재설치를 시도해보세요'));
+            console.log(chalk.yellow('   • 실패한 도구만 롤백 후 다시 설치하세요'));
+            console.log(chalk.yellow('   • 네트워크 연결을 확인하고 다시 시도하세요'));
+        }
+    }
+    
+    console.log(chalk.blue.bold('\n' + '='.repeat(60)));
+}
+
+// 검증 결과 표시 함수 (기존 함수는 유지, 새로운 리포트 함수와 함께 사용)
+function displayValidationResults(validationResults, language) {
+    return generateInstallationReport(validationResults, language, 'install');
+}
+
+// 도구별 디렉토리 매핑 함수 (중복 제거됨 - 위의 함수 사용)
+
+// 특정 도구의 백업 파일 목록 가져오기
+async function getBackupFilesForTool(tool, backupDir) {
+    const toolBackupFiles = [];
+    
+    try {
+        const backupFiles = await fs.readdir(backupDir);
+        const toolDir = getToolDirectory(tool);
+        
+        if (!toolDir) return toolBackupFiles;
+        
+        // 도구별 백업 파일 패턴 매칭
+        const patterns = {
+            claudeCode: /^claude-commands-aiwf-.*\.bak$/,
+            geminiCLI: /^gemini-prompts-aiwf-.*\.bak$/,
+            cursor: /^cursor-rules-.*\.bak$/,
+            windsurf: /^windsurf-rules-.*\.bak$/,
+            aiwf: /^aiwf-.*\.bak$/
+        };
+        
+        const pattern = patterns[tool];
+        if (pattern) {
+            const matchingFiles = backupFiles.filter(file => pattern.test(file));
+            for (const file of matchingFiles) {
+                toolBackupFiles.push({
+                    backupFile: path.join(backupDir, file),
+                    originalPath: restoreOriginalPath(file, tool)
+                });
+            }
+        }
+        
+    } catch (error) {
+        // 백업 디렉토리가 없거나 읽을 수 없는 경우
+    }
+    
+    return toolBackupFiles;
+}
+
+// 백업 파일명에서 원본 경로 복원
+function restoreOriginalPath(backupFileName, tool) {
+    const toolDirs = {
+        claudeCode: '.claude/commands/aiwf',
+        geminiCLI: '.gemini/prompts/aiwf',
+        cursor: '.cursor/rules',
+        windsurf: '.windsurf/rules',
+        aiwf: '.aiwf'
+    };
+    
+    const baseDir = toolDirs[tool];
+    if (!baseDir) return null;
+    
+    // 백업 파일명에서 원본 파일명 추출
+    let originalFileName = backupFileName;
+    
+    // 도구별 프리픽스 제거
+    const prefixes = {
+        claudeCode: 'claude-commands-aiwf-',
+        geminiCLI: 'gemini-prompts-aiwf-',
+        cursor: 'cursor-rules-',
+        windsurf: 'windsurf-rules-',
+        aiwf: 'aiwf-'
+    };
+    
+    const prefix = prefixes[tool];
+    if (prefix && originalFileName.startsWith(prefix)) {
+        originalFileName = originalFileName.substring(prefix.length);
+    }
+    
+    // .bak 확장자 제거
+    if (originalFileName.endsWith('.bak')) {
+        originalFileName = originalFileName.substring(0, originalFileName.length - 4);
+    }
+    
+    // 하이픈을 슬래시로 복원 (하위 디렉토리 구조)
+    originalFileName = originalFileName.replace(/-/g, '/');
+    
+    return path.join(baseDir, originalFileName);
+}
+
+// 개별 백업 파일 복원 (중복 제거됨 - 위의 함수 사용)
+
+// 특정 도구 롤백 함수
+async function rollbackTool(tool, backupDir, language = 'ko') {
+    const msg = messages[language];
+    const spinner = ora(
+        language === 'ko' ? 
+        `${tool} 도구를 롤백하는 중...` : 
+        `Rolling back ${tool}...`
+    ).start();
+    
+    try {
+        // 1. 해당 도구의 디렉토리 삭제
+        const toolDir = getToolDirectory(tool);
+        if (toolDir) {
+            const dirExists = await fs.access(toolDir).then(() => true).catch(() => false);
+            if (dirExists) {
+                await fs.rm(toolDir, { recursive: true, force: true });
+                spinner.text = language === 'ko' ? 
+                    `${tool} 디렉토리 삭제 완료` : 
+                    `${tool} directory removed`;
+            }
+        }
+        
+        // 2. 백업에서 복원
+        const backupFiles = await getBackupFilesForTool(tool, backupDir);
+        let restoredCount = 0;
+        
+        for (const backup of backupFiles) {
+            const restored = await restoreBackupFile(backup);
+            if (restored) {
+                restoredCount++;
+            }
+        }
+        
+        if (restoredCount > 0) {
+            spinner.succeed(chalk.green(
+                language === 'ko' ? 
+                `${tool} 롤백 완료 (${restoredCount}개 파일 복원)` : 
+                `${tool} rolled back successfully (${restoredCount} files restored)`
+            ));
+            return { success: true, restoredCount };
+        } else {
+            spinner.warn(chalk.yellow(
+                language === 'ko' ? 
+                `${tool} 롤백: 복원할 백업 파일이 없음` : 
+                `${tool} rollback: No backup files to restore`
+            ));
+            return { success: true, restoredCount: 0 };
+        }
+        
+    } catch (error) {
+        spinner.fail(chalk.red(
+            language === 'ko' ? 
+            `${tool} 롤백 실패: ${error.message}` : 
+            `Failed to rollback ${tool}: ${error.message}`
+        ));
+        return { success: false, error: error.message };
+    }
+}
+
+// =============================================================================
+// ROLLBACK SYSTEM IMPLEMENTATION
+// =============================================================================
+
+// 도구별 디렉토리 경로 가져오기 (중복 제거됨 - 위의 getToolDirectory 함수 사용)
+
+// 백업에서 특정 도구의 파일들 찾기 (중복 제거됨 - 위의 함수 사용)
+
+// 백업 파일명에서 원래 경로 복원
+function restoreBackupPath(backupFileName, tool) {
+    const toolDir = getToolDirectory(tool);
+    if (!toolDir) return null;
+    
+    // 백업 파일명 패턴: claude-commands-aiwf-foo.md.bak -> .claude/commands/aiwf/foo.md
+    if (backupFileName.startsWith('claude-commands-aiwf-')) {
+        const relativePath = backupFileName
+            .replace('claude-commands-aiwf-', '')
+            .replace('.bak', '')
+            .replace(/-/g, '/');
+        return path.join('.claude/commands/aiwf', relativePath);
+    }
+    
+    // 백업 파일명 패턴: aiwf-foo-bar.md.bak -> .aiwf/foo/bar.md
+    if (backupFileName.startsWith('aiwf-')) {
+        const relativePath = backupFileName
+            .replace('aiwf-', '')
+            .replace('.bak', '')
+            .replace(/-/g, '/');
+        return path.join('.aiwf', relativePath);
+    }
+    
+    // 기타 패턴
+    return backupFileName.replace('.bak', '');
+}
+
+// 개별 백업 파일 복원 (중복 제거됨 - 위의 함수 사용)
+
+// 특정 도구 롤백 함수
+
+// 다중 도구 롤백 함수
+async function rollbackMultipleTools(failedTools, backupDir, language = 'en') {
+    const results = {
+        success: [],
+        failed: [],
+        partial: []
+    };
+    
+    console.log(chalk.blue('\n🔄 Starting rollback process...'));
+    
+    for (const toolInfo of failedTools) {
+        const toolName = typeof toolInfo === 'string' ? toolInfo : toolInfo.tool;
+        const rollbackResult = await rollbackTool(toolName, backupDir, language);
+        
+        if (rollbackResult === true) {
+            results.success.push(toolName);
+        } else if (rollbackResult === false) {
+            results.failed.push(toolName);
+        } else {
+            results.partial.push(toolName);
+        }
+    }
+    
+    // 롤백 결과 요약
+    console.log(chalk.blue('\n📋 Rollback Summary:'));
+    if (results.success.length > 0) {
+        console.log(chalk.green(`✅ Successfully rolled back: ${results.success.join(', ')}`));
+    }
+    if (results.partial.length > 0) {
+        console.log(chalk.yellow(`⚠️  Partially rolled back: ${results.partial.join(', ')}`));
+    }
+    if (results.failed.length > 0) {
+        console.log(chalk.red(`❌ Failed to rollback: ${results.failed.join(', ')}`));
+    }
+    
+    return results;
+}
+
+// 개선된 재설치 옵션 제공 함수
+async function offerReinstallationOptions(validationResults, language) {
+    console.log(chalk.yellow(
+        language === 'ko' ? 
+        '\n⚠️  일부 설치가 실패했습니다. 무엇을 하시겠습니까?' :
+        '\n⚠️  Some installations failed. What would you like to do?'
+    ));
+    
+    // 실패한 도구들 나열 - 새로운 형식에 맞게 수정
+    const failedTools = validationResults.failed.map(({tool}) => tool);
+    
+    if (failedTools.length > 0) {
+        console.log(chalk.red(
+            language === 'ko' ? 
+            `실패한 도구: ${failedTools.join(', ')}` :
+            `Failed tools: ${failedTools.join(', ')}`
+        ));
+    }
+    
+    const response = await prompts({
+        type: 'select',
+        name: 'action',
+        message: language === 'ko' ? '어떤 작업을 수행하시겠습니까?' : 'What would you like to do?',
+        choices: [
+            { 
+                title: language === 'ko' ? '전체 재설치' : 'Full reinstallation', 
+                value: 'reinstall' 
+            },
+            { 
+                title: language === 'ko' ? '실패한 도구만 롤백' : 'Rollback failed tools only', 
+                value: 'rollback' 
+            },
+            { 
+                title: language === 'ko' ? '현재 상태 유지' : 'Keep current state', 
+                value: 'keep' 
+            }
+        ]
+    });
+    
+    return response.action;
+}
+
+// =============================================================================
+// ROLLBACK SYSTEM
+// =============================================================================
+
+// 도구별 롤백 함수
+// 도구별 백업 복원 함수
+async function restoreToolFromBackup(tool, backupDir) {
+    try {
+        const backupFiles = await fs.readdir(backupDir);
+        const toolBackups = backupFiles.filter(f => f.endsWith('.bak'));
+        
+        for (const backup of toolBackups) {
+            let shouldRestore = false;
+            let originalPath = '';
+            
+            // 도구별 백업 파일 패턴 매칭
+            switch (tool) {
+                case 'claudeCode':
+                    if (backup.startsWith('claude-commands-aiwf-')) {
+                        shouldRestore = true;
+                        const fileName = backup.replace('claude-commands-aiwf-', '').replace('.bak', '');
+                        originalPath = path.join('.claude/commands/aiwf', fileName);
+                    }
+                    break;
+                case 'aiwf':
+                    if (backup.startsWith('aiwf-')) {
+                        shouldRestore = true;
+                        const relativePath = backup.replace('aiwf-', '').replace(/-/g, '/').replace('.bak', '');
+                        originalPath = '.aiwf/' + relativePath;
+                    }
+                    break;
+                // cursor와 windsurf는 현재 백업하지 않음 (rules 파일은 동적 생성)
+            }
+            
+            if (shouldRestore) {
+                const backupPath = path.join(backupDir, backup);
+                await fs.mkdir(path.dirname(originalPath), { recursive: true });
+                await fs.copyFile(backupPath, originalPath);
+            }
+        }
+    } catch (error) {
+        // 백업 복원 실패는 심각하지 않음
+        console.warn(`Warning: Could not restore ${tool} from backup: ${error.message}`);
+    }
+}
+
+// 실패한 도구들에 대한 일괄 롤백
+async function rollbackFailedTools(failedTools, language) {
+    const results = {
+        success: [],
+        failed: []
+    };
+    
+    for (const toolInfo of failedTools) {
+        const tool = typeof toolInfo === 'object' ? toolInfo.tool : toolInfo;
+        const rollbackSuccess = await rollbackTool(tool, language);
+        
+        if (rollbackSuccess) {
+            results.success.push(tool);
+        } else {
+            results.failed.push(tool);
+        }
+    }
+    
+    return results;
+}
+
+// =============================================================================
+// MAIN INSTALLATION FUNCTION
+// =============================================================================
+
 async function installAIWF(options = {}) {
     const debugLog = options.debugLog || false;
 
-    // 언어 선택
-    let selectedLanguage = 'en'; // 기본값은 영어
+    // 지능적 언어 선택 시스템
+    let selectedLanguage = DEFAULT_LANGUAGE;
+    
     if (!options.force) {
-        const languageResponse = await prompts({
-            type: 'select',
-            name: 'language',
-            message: 'Please select language / 언어를 선택해주세요:',
-            choices: [
-                { title: 'English', value: 'en' },
-                { title: '한국어 (Korean)', value: 'ko' }
-            ]
-        });
+        // 1. 기존 설정이 있는지 확인
+        const existingConfig = await loadUserLanguageConfig();
+        
+        if (existingConfig && existingConfig.language) {
+            selectedLanguage = existingConfig.language;
+            console.log(chalk.blue(`🌐 기존 언어 설정을 사용합니다 / Using existing language setting: ${selectedLanguage}`));
+        } else {
+            // 2. 자동 언어 감지 시도
+            const detectedLang = await detectLanguage();
+            
+            console.log(chalk.gray(`🔍 시스템 언어 감지 / System language detected: ${detectedLang}`));
+            
+            // 3. 사용자에게 언어 선택 제공 (감지된 언어를 기본값으로)
+            const languageResponse = await prompts({
+                type: 'select',
+                name: 'language',
+                message: 'Please select language / 언어를 선택해주세요:',
+                choices: [
+                    { title: 'English', value: 'en' },
+                    { title: '한국어 (Korean)', value: 'ko' }
+                ],
+                initial: SUPPORTED_LANGUAGES.indexOf(detectedLang) !== -1 ? 
+                         SUPPORTED_LANGUAGES.indexOf(detectedLang) : 0
+            });
 
-        if (languageResponse.language) {
-            selectedLanguage = languageResponse.language;
+            if (languageResponse.language) {
+                selectedLanguage = languageResponse.language;
+            } else {
+                selectedLanguage = detectedLang;
+            }
+            
+            // 4. 선택된 언어를 설정으로 저장
+            try {
+                await saveUserLanguageConfig(selectedLanguage, {
+                    autoDetect: true,
+                    fallback: DEFAULT_LANGUAGE
+                });
+                console.log(chalk.green(`✅ 언어 설정이 저장되었습니다 / Language preference saved: ${selectedLanguage}`));
+            } catch (error) {
+                console.warn(chalk.yellow(`⚠️ 언어 설정 저장 실패 / Failed to save language preference: ${error.message}`));
+            }
+        }
+    } else {
+        // Force 모드일 때도 자동 감지 시도
+        try {
+            selectedLanguage = await detectLanguage();
+        } catch (error) {
+            selectedLanguage = DEFAULT_LANGUAGE;
         }
     }
 
@@ -337,8 +1511,8 @@ async function installAIWF(options = {}) {
     console.log(chalk.gray(msg.description));
     console.log(chalk.gray(msg.optimized));
 
-    // 언어별 경로 설정
-    const languagePath = selectedLanguage === 'en' ? 'en' : 'ko';
+    // 언어별 경로 설정 (언어 유틸리티 사용)
+    const languagePath = getInstallationLanguagePath(selectedLanguage);
     const GITHUB_CONTENT_LANGUAGE_PREFIX = `${GITHUB_CONTENT_PREFIX}/${languagePath}`;
 
     const hasExisting = await checkExistingInstallation();
@@ -547,6 +1721,54 @@ async function installAIWF(options = {}) {
             console.log(chalk.gray(`\n${msg.checkDocs}`));
         }
 
+        // 설치 검증 실행
+        console.log(chalk.blue('\n🔍 Installation Validation / 설치 검증을 시작합니다...'));
+        // Use specification-compliant validation function
+        const selectedTools = ['claude-code', 'cursor', 'windsurf']; // Default tools for this version
+        const validationResults = await validateInstallation(selectedTools, selectedLanguage);
+        displaySpecCompliantValidationResults(validationResults, selectedLanguage);
+        
+        // 부분 실패 시 재설치/롤백 옵션 제공  
+        if (validationResults.failed.length > 0) {
+            const action = await offerReinstallationOptions(validationResults, selectedLanguage);
+            
+            if (action === 'reinstall') {
+                console.log(chalk.blue('\n🔄 재설치를 시작합니다... / Starting reinstallation...'));
+                // 재귀적으로 설치를 다시 시도 (한 번만)
+                if (!options.isRetry) {
+                    return await installAIWF({ ...options, isRetry: true });
+                }
+            } else if (action === 'rollback') {
+                console.log(chalk.blue('\n↩️  실패한 도구를 롤백합니다... / Rolling back failed tools...'));
+                
+                // 실패한 도구들만 롤백 - 새로운 형식에 맞게 수정
+                const failedTools = validationResults.failed.map(({tool}) => tool);
+                
+                let rollbackResults = {};
+                for (const tool of failedTools) {
+                    if (BACKUP_DIR) {
+                        const rollbackResult = await rollbackTool(tool, BACKUP_DIR, selectedLanguage);
+                        rollbackResults[tool] = rollbackResult;
+                    }
+                }
+                
+                // 롤백 후 다시 검증
+                console.log(chalk.blue('\n🔍 롤백 후 재검증... / Re-validating after rollback...'));
+                const postRollbackValidation = await validateInstallation(selectedTools, selectedLanguage);
+                displaySpecCompliantValidationResults(postRollbackValidation, selectedLanguage);
+                
+                // 롤백 결과 요약
+                console.log(chalk.blue('\n=== Rollback Summary / 롤백 요약 ==='));
+                for (const [tool, result] of Object.entries(rollbackResults)) {
+                    if (result.success) {
+                        console.log(chalk.green(`✅ ${tool}: ${result.restoredCount} files restored`));
+                    } else {
+                        console.log(chalk.red(`❌ ${tool}: ${result.error}`));
+                    }
+                }
+            }
+        }
+
         console.log(chalk.green(msg.enjoy));
 
     } catch (error) {
@@ -612,8 +1834,114 @@ async function restoreFromBackup(spinner, msg) {
 program
     .name('aiwf')
     .version('1.0.1')
-    .description('AIWF Installer')
+    .description('AIWF - AI Workflow Framework');
+
+// Install command (default action)
+program
+    .command('install', { isDefault: true })
+    .description('Install AIWF framework')
     .option('-f, --force', 'Force install without prompts')
     .action((options) => installAIWF({ ...options, debugLog: true }));
 
+// AI Tool command
+program
+    .command('ai-tool <subcommand> [tool-name]')
+    .description('Manage AI tool integrations')
+    .action(async (subcommand, toolName) => {
+        const aiToolCmd = new AIToolCommand();
+        const args = [subcommand];
+        if (toolName) args.push(toolName);
+        await aiToolCmd.execute(args);
+    });
+
+// Cache management commands
+const cache = program.command('cache');
+cache.description('Manage offline template cache');
+
+cache
+    .command('download')
+    .description('Download templates for offline use')
+    .option('--all', 'Download all templates')
+    .option('--type <type>', 'Download specific type (ai-tools, projects)')
+    .action(async (options) => {
+        const cacheCLI = new CacheCLI();
+        try {
+            await cacheCLI.init();
+            await cacheCLI.downloadCommand(options);
+        } catch (error) {
+            console.error(chalk.red('Cache download failed:', error.message));
+            process.exit(1);
+        } finally {
+            await cacheCLI.cleanup();
+        }
+    });
+
+cache
+    .command('list')
+    .description('List cached templates')
+    .option('--type <type>', 'Filter by type (ai-tools, projects)')
+    .action(async (options) => {
+        const cacheCLI = new CacheCLI();
+        try {
+            await cacheCLI.init();
+            await cacheCLI.listCommand(options);
+        } catch (error) {
+            console.error(chalk.red('Cache list failed:', error.message));
+            process.exit(1);
+        } finally {
+            await cacheCLI.cleanup();
+        }
+    });
+
+cache
+    .command('clean')
+    .description('Clean up cached templates')
+    .option('--all', 'Clear all cached templates')
+    .option('--max-age <days>', 'Maximum age in days (default: 7)', '7')
+    .action(async (options) => {
+        const cacheCLI = new CacheCLI();
+        try {
+            await cacheCLI.init();
+            await cacheCLI.cleanCommand(options);
+        } catch (error) {
+            console.error(chalk.red('Cache clean failed:', error.message));
+            process.exit(1);
+        } finally {
+            await cacheCLI.cleanup();
+        }
+    });
+
+cache
+    .command('update')
+    .description('Check for template updates')
+    .option('--install', 'Install available updates')
+    .action(async (options) => {
+        const cacheCLI = new CacheCLI();
+        try {
+            await cacheCLI.init();
+            await cacheCLI.updateCommand(options);
+        } catch (error) {
+            console.error(chalk.red('Cache update failed:', error.message));
+            process.exit(1);
+        } finally {
+            await cacheCLI.cleanup();
+        }
+    });
+
+cache
+    .command('status')
+    .description('Show cache system status')
+    .action(async () => {
+        const cacheCLI = new CacheCLI();
+        try {
+            await cacheCLI.init();
+            await cacheCLI.statusCommand();
+        } catch (error) {
+            console.error(chalk.red('Cache status failed:', error.message));
+            process.exit(1);
+        } finally {
+            await cacheCLI.cleanup();
+        }
+    });
+
 program.parse(process.argv);