aiwf 0.1.0 → 0.3.0

package/index.js

@@ -17,11 +17,11 @@ 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_CONTENT_PREFIX = 'claude-code/moonklabs';
+const GITHUB_CONTENT_PREFIX = 'claude-code/aiwf';
 
 async function fetchGitHubContent(url) {
     return new Promise((resolve, reject) => {
-        https.get(url, { headers: { 'User-Agent': 'hello-moonklabs' } }, (res) => {
+        https.get(url, { headers: { 'User-Agent': 'aiwf' } }, (res) => {
             let data = '';
             res.on('data', chunk => data += chunk);
             res.on('end', () => {
@@ -40,7 +40,7 @@ async function fetchGitHubContent(url) {
 
 async function downloadFile(url, destPath) {
     return new Promise((resolve, reject) => {
-        https.get(url, { headers: { 'User-Agent': 'hello-moonklabs' } }, (response) => {
+        https.get(url, { headers: { 'User-Agent': 'aiwf' } }, (response) => {
             if (response.statusCode !== 200) {
                 response.destroy();
                 reject(new Error(`Failed to download ${url}: ${response.statusCode}`));
@@ -69,10 +69,12 @@ async function getDirectoryStructure(path = '') {
     return JSON.parse(content);
 }
 
+const COMMANDS_DIR = '.claude/commands/aiwf';
+
 async function checkExistingInstallation() {
-    const moonklabsExists = await fs.access('.moonklabs').then(() => true).catch(() => false);
-    const claudeCommandsExists = await fs.access('.claude/commands/moonklabs').then(() => true).catch(() => false);
-    return moonklabsExists || claudeCommandsExists;
+    const aiwfExists = await fs.access('.aiwf').then(() => true).catch(() => false);
+    const claudeCommandsExists = await fs.access(COMMANDS_DIR).then(() => true).catch(() => false);
+    return aiwfExists || claudeCommandsExists;
 }
 
 // 백업 폴더명 생성 함수
@@ -85,7 +87,7 @@ function getBackupDirName() {
     const h = pad(now.getHours());
     const min = pad(now.getMinutes());
     const s = pad(now.getSeconds());
-    return `.moonklabs/backup_${y}${m}${d}_${h}${min}${s}`;
+    return `.aiwf/backup_${y}${m}${d}_${h}${min}${s}`;
 }
 
 let BACKUP_DIR = null;
@@ -97,11 +99,11 @@ async function backupFile(filePath, backupDir) {
             await fs.mkdir(backupDir, { recursive: true });
             const backupPath = `${filePath}.bak`;
             await fs.copyFile(filePath, backupPath);
-            // 상대경로 보존: .claude/commands/moonklabs/foo.md -> backupDir/claude-commands-moonklabs-foo.md.bak
+            // 상대경로 보존: .claude/commands/aiwf/foo.md -> backupDir/claude-commands-aiwf-foo.md.bak
             let bakFileName;
-            if (filePath.startsWith('.claude/commands/moonklabs/')) {
+            if (filePath.startsWith(COMMANDS_DIR + '/')) {
                 bakFileName = filePath.replace(/\//g, '-').replace(/^\./, '') + '.bak';
-            } else if (filePath.startsWith('.moonklabs/')) {
+            } else if (filePath.startsWith('.aiwf/')) {
                 bakFileName = filePath.replace(/\//g, '-').replace(/^\./, '') + '.bak';
             } else {
                 bakFileName = path.basename(filePath) + '.bak';
@@ -116,18 +118,18 @@ async function backupFile(filePath, backupDir) {
     return null;
 }
 
-async function backupCommandsAndDocs() {
+async function backupCommandsAndDocs(msg) {
     if (!BACKUP_DIR) BACKUP_DIR = getBackupDirName();
-    const spinner = ora('기존 명령어 및 문서 백업 중...').start();
+    const spinner = ora(msg.backingUp).start();
     const backedUpFiles = [];
     await fs.mkdir(BACKUP_DIR, { recursive: true });
     try {
         // Files that will be updated and need backup
         const filesToBackup = [
-            '.moonklabs/CLAUDE.md',
-            '.moonklabs/02_REQUIREMENTS/CLAUDE.md',
-            '.moonklabs/03_SPRINTS/CLAUDE.md',
-            '.moonklabs/04_GENERAL_TASKS/CLAUDE.md'
+            '.aiwf/CLAUDE.md',
+            '.aiwf/02_REQUIREMENTS/CLAUDE.md',
+            '.aiwf/03_SPRINTS/CLAUDE.md',
+            '.aiwf/04_GENERAL_TASKS/CLAUDE.md'
         ];
         // Backup CLAUDE.md files
         for (const file of filesToBackup) {
@@ -137,13 +139,12 @@ async function backupCommandsAndDocs() {
             }
         }
         // Backup all command files
-        const commandsDir = '.claude/commands/moonklabs';
-        const commandsExist = await fs.access(commandsDir).then(() => true).catch(() => false);
+        const commandsExist = await fs.access(COMMANDS_DIR).then(() => true).catch(() => false);
         if (commandsExist) {
             try {
-                const commandFiles = await fs.readdir(commandsDir);
+                const commandFiles = await fs.readdir(COMMANDS_DIR);
                 for (const file of commandFiles) {
-                    const filePath = path.join(commandsDir, file);
+                    const filePath = path.join(COMMANDS_DIR, file);
                     const stat = await fs.stat(filePath);
                     if (stat.isFile() && file.endsWith('.md')) {
                         const backupPath = await backupFile(filePath, BACKUP_DIR);
@@ -157,18 +158,18 @@ async function backupCommandsAndDocs() {
             }
         }
         if (backedUpFiles.length > 0) {
-            spinner.succeed(chalk.green(`${backedUpFiles.length}개 파일 백업 완료 (*.bak)`));
+            spinner.succeed(chalk.green(msg.backupComplete.replace('{count}', backedUpFiles.length)));
         } else {
-            spinner.succeed(chalk.gray('백업할 기존 파일이 없습니다'));
+            spinner.succeed(chalk.gray(msg.noFilesToBackup));
         }
         return backedUpFiles;
     } catch (error) {
-        spinner.fail(chalk.red('백업 실패'));
+        spinner.fail(chalk.red(msg.backupFailed));
         throw error;
     }
 }
 
-async function downloadDirectory(githubPath, localPath, spinner) {
+async function downloadDirectory(githubPath, localPath, spinner, msg) {
     await fs.mkdir(localPath, { recursive: true });
 
     const items = await getDirectoryStructure(githubPath);
@@ -177,9 +178,9 @@ async function downloadDirectory(githubPath, localPath, spinner) {
         const itemLocalPath = path.join(localPath, item.name);
 
         if (item.type === 'dir') {
-            await downloadDirectory(item.path, itemLocalPath, spinner);
+            await downloadDirectory(item.path, itemLocalPath, spinner, msg);
         } else if (item.type === 'file') {
-            spinner.text = `${item.path} 다운로드 중...`;
+            spinner.text = msg.downloadingFile.replace('{path}', item.path);
             await downloadFile(item.download_url, itemLocalPath);
         }
     }
@@ -191,11 +192,154 @@ function logWithSpinner(spinner, message, debugLog) {
     if (spinner) spinner.text = message;
 }
 
-async function installMoonklabs(options = {}) {
+// 언어별 메시지 정의
+const messages = {
+    ko: {
+        welcome: '\n🎉 AIWF에 오신 것을 환영합니다!\n',
+        description: '이 설치 프로그램은 AIWF AI 프롬프트 프레임워크를 설정합니다',
+        optimized: '특별히 Claude Code 에 최적화 되어있습니다.\n',
+        selectLanguage: 'Please select language / 언어를 선택해주세요:',
+        korean: '한국어 (Korean)',
+        english: 'English',
+        existingDetected: '기존 AIWF 설치가 감지되었습니다. 무엇을 하시겠습니까?',
+        updateOption: '업데이트 (명령어와 문서만 업데이트하고 작업 내용은 보존)',
+        skipOption: '설치 건너뛰기',
+        cancelOption: '취소',
+        installCancelled: '\n설치가 취소되었습니다.',
+        backingUp: '기존 명령어 및 문서 백업 중...',
+        fetching: 'GitHub에서 AIWF 프레임워크를 가져오는 중...',
+        downloading: 'AIWF 프레임워크 파일을 다운로드하는 중...',
+        updatingDocs: '문서를 업데이트하는 중...',
+        downloadingCommands: 'AIWF 명령어를 새로 다운로드하는 중...',
+        updateSuccess: '✅ AIWF 프레임워크가 성공적으로 업데이트되었습니다!',
+        installSuccess: '✅ AIWF 프레임워크가 성공적으로 설치되었습니다!',
+        enjoy: '\nEnjoy AIWF! 🚀\n',
+        backupComplete: '{count}개 파일 백업 완료 (*.bak)',
+        noFilesToBackup: '백업할 기존 파일이 없습니다',
+        backupFailed: '백업 실패',
+        downloadingFile: '{path} 다운로드 중...',
+        downloadingTemplates: '템플릿 디렉토리를 다운로드 중...',
+        templatesNotFound: '템플릿 디렉토리를 찾을 수 없어 건너뜁니다...',
+        deletingOldCommands: '기존 AIWF 명령어 폴더를 삭제하는 중...',
+        commandsNotFound: '명령어 디렉토리를 찾을 수 없어 건너뜁니다...',
+        downloadingRulesGlobal: 'rules/global 폴더를 다운로드 중...',
+        rulesGlobalNotFound: 'rules/global 폴더를 찾을 수 없어 건너뜁니다...',
+        downloadingRulesManual: 'rules/manual 폴더를 다운로드 중...',
+        rulesManualNotFound: 'rules/manual 폴더를 찾을 수 없어 건너뜁니다...',
+        updateHistory: '🔄 업데이트 내역:',
+        updatedCommands: '내의 명령어',
+        updatedDocs: '문서 (CLAUDE.md 파일)',
+        workPreserved: '💾 작업 내용은 보존되었습니다:',
+        allFilesPreserved: '모든 작업, 스프린트, 및 프로젝트 파일이 변경되지 않음',
+        backupCreated: '백업은 *.bak 파일로 만들어짐',
+        structureCreated: '📁 생성된 구조:',
+        aiwfRoot: '프로젝트 관리 루트',
+        claudeCommands: 'Claude 사용자 명령어',
+        nextSteps: '🚀 다음 단계:',
+        nextStep1: 'Claude Code에서 이 프로젝트를 엽니다',
+        nextStep2: '/aiwf_<command> 명령어를 사용하여 프로젝트를 관리하세요',
+        nextStep3: '/aiwf_initialize를 실행하여 프로젝트를 설정하세요',
+        gettingStarted: '✨ 시작하려면:',
+        startStep1: '새 터미널을 열거나 쉘 프로필을 소싱하세요 (예: source ~/.zshrc)',
+        startStep2: '다음을 실행하세요: claude 를 실행하여 사용 가능한 명령어를 확인하세요.',
+        checkDocs: '자세한 내용은 .aiwf 디렉토리의 문서를 확인하세요.',
+        updateFailed: '업데이트 실패',
+        installFailed: '설치 실패',
+        noBackupFound: '복원할 백업 폴더가 없습니다.',
+        restoringFromBackup: '백업에서 복원 중...',
+        restoreSuccess: '성공적으로 복원되었습니다.',
+        restoreFailed: '복원에 실패했습니다.',
+        cannotRestore: '파일을 복원할 수 없습니다. 수동 확인이 필요합니다.'
+    },
+    en: {
+        welcome: '\n🎉 Welcome to AIWF!\n',
+        description: 'This installer sets up the AIWF AI prompt framework',
+        optimized: 'Specially optimized for Claude Code.\n',
+        selectLanguage: 'Please select language / 언어를 선택해주세요:',
+        korean: '한국어 (Korean)',
+        english: 'English',
+        existingDetected: 'Existing AIWF installation detected. What would you like to do?',
+        updateOption: 'Update (Update commands and docs only, preserve work content)',
+        skipOption: 'Skip installation',
+        cancelOption: 'Cancel',
+        installCancelled: '\nInstallation cancelled.',
+        backingUp: 'Backing up existing commands and documents...',
+        fetching: 'Fetching AIWF framework from GitHub...',
+        downloading: 'Downloading AIWF framework files...',
+        updatingDocs: 'Updating documentation...',
+        downloadingCommands: 'Downloading AIWF commands...',
+        updateSuccess: '✅ AIWF framework updated successfully!',
+        installSuccess: '✅ AIWF framework installed successfully!',
+        enjoy: '\nEnjoy AIWF! 🚀\n',
+        backupComplete: '{count} files backed up (*.bak)',
+        noFilesToBackup: 'No existing files to backup',
+        backupFailed: 'Backup failed',
+        downloadingFile: 'Downloading {path}...',
+        downloadingTemplates: 'Downloading template directories...',
+        templatesNotFound: 'Template directories not found, skipping...',
+        deletingOldCommands: 'Deleting existing AIWF commands folder...',
+        commandsNotFound: 'Commands directory not found, skipping...',
+        downloadingRulesGlobal: 'Downloading rules/global folder...',
+        rulesGlobalNotFound: 'rules/global folder not found, skipping...',
+        downloadingRulesManual: 'Downloading rules/manual folder...',
+        rulesManualNotFound: 'rules/manual folder not found, skipping...',
+        updateHistory: '🔄 Update History:',
+        updatedCommands: '/ commands',
+        updatedDocs: 'Documentation (CLAUDE.md files)',
+        workPreserved: '💾 Work preserved:',
+        allFilesPreserved: 'All work, sprints, and project files unchanged',
+        backupCreated: 'Backups created as *.bak files',
+        structureCreated: '📁 Structure created:',
+        aiwfRoot: 'Project management root',
+        claudeCommands: 'Claude user commands',
+        nextSteps: '🚀 Next steps:',
+        nextStep1: 'Open this project in Claude Code',
+        nextStep2: 'Use /aiwf_<command> commands to manage your project',
+        nextStep3: 'Run /aiwf_initialize to set up your project',
+        gettingStarted: '✨ Getting started:',
+        startStep1: 'Open a new terminal or source your shell profile (e.g. source ~/.zshrc)',
+        startStep2: 'Run: claude to see available commands.',
+        checkDocs: 'For more details, check the documentation in the .aiwf directory.',
+        updateFailed: 'Update failed',
+        installFailed: 'Installation failed',
+        noBackupFound: 'No backup folder found to restore.',
+        restoringFromBackup: 'Restoring from backup...',
+        restoreSuccess: 'Successfully restored.',
+        restoreFailed: 'Restore failed.',
+        cannotRestore: 'Cannot restore file. Manual verification required.'
+    }
+};
+
+async function installAIWF(options = {}) {
     const debugLog = options.debugLog || false;
-    console.log(chalk.blue.bold('\n🎉 Hello Moonklabs에 오신 것을 환영합니다!\n'));
-    console.log(chalk.gray('이 설치 프로그램은 Moonklabs AI 프롬프트 프레임워크를 설정합니다'));
-    console.log(chalk.gray('특별히 Claude Code 에 최적화 되어있습니다.\n'));
+
+    // 언어 선택
+    let selectedLanguage = 'en'; // 기본값은 영어
+    if (!options.force) {
+        const languageResponse = await prompts({
+            type: 'select',
+            name: 'language',
+            message: 'Please select language / 언어를 선택해주세요:',
+            choices: [
+                { title: 'English', value: 'en' },
+                { title: '한국어 (Korean)', value: 'ko' }
+            ]
+        });
+
+        if (languageResponse.language) {
+            selectedLanguage = languageResponse.language;
+        }
+    }
+
+    const msg = messages[selectedLanguage];
+
+    console.log(chalk.blue.bold(msg.welcome));
+    console.log(chalk.gray(msg.description));
+    console.log(chalk.gray(msg.optimized));
+
+    // 언어별 경로 설정
+    const languagePath = selectedLanguage === 'en' ? 'en' : 'ko';
+    const GITHUB_CONTENT_LANGUAGE_PREFIX = `${GITHUB_CONTENT_PREFIX}/${languagePath}`;
 
     const hasExisting = await checkExistingInstallation();
 
@@ -203,51 +347,51 @@ async function installMoonklabs(options = {}) {
         const response = await prompts({
             type: 'select',
             name: 'action',
-            message: '기존 Moonklabs 설치가 감지되었습니다. 무엇을 하시겠습니까?',
+            message: msg.existingDetected,
             choices: [
-                { title: '업데이트 (명령어와 문서만 업데이트하고 작업 내용은 보존)', value: 'update' },
-                { title: '설치 건너뛰기', value: 'skip' },
-                { title: '취소', value: 'cancel' }
+                { title: msg.updateOption, value: 'update' },
+                { title: msg.skipOption, value: 'skip' },
+                { title: msg.cancelOption, value: 'cancel' }
             ]
         });
 
         if (response.action === 'skip' || response.action === 'cancel') {
-            console.log(chalk.yellow('\n설치가 취소되었습니다.'));
+            console.log(chalk.yellow(msg.installCancelled));
             process.exit(0);
         }
 
         if (response.action === 'update') {
-            await backupCommandsAndDocs();
+            await backupCommandsAndDocs(msg);
         }
     }
 
-    const spinner = ora('GitHub에서 Moonklabs 프레임워크를 가져오는 중...').start();
+    const spinner = ora(msg.fetching).start();
 
     try {
-        // Create .moonklabs directory structure
-        const moonklabsDirs = [
-            '.moonklabs',
-            '.moonklabs/01_PROJECT_DOCS',
-            '.moonklabs/02_REQUIREMENTS',
-            '.moonklabs/03_SPRINTS',
-            '.moonklabs/04_GENERAL_TASKS',
-            '.moonklabs/05_ARCHITECTURE_DECISIONS',
-            '.moonklabs/10_STATE_OF_PROJECT',
-            '.moonklabs/98_PROMPTS',
-            '.moonklabs/99_TEMPLATES'
+        // Create .aiwf directory structure
+        const aiwfDirs = [
+            '.aiwf',
+            '.aiwf/01_PROJECT_DOCS',
+            '.aiwf/02_REQUIREMENTS',
+            '.aiwf/03_SPRINTS',
+            '.aiwf/04_GENERAL_TASKS',
+            '.aiwf/05_ARCHITECTURE_DECISIONS',
+            '.aiwf/10_STATE_OF_PROJECT',
+            '.aiwf/98_PROMPTS',
+            '.aiwf/99_TEMPLATES'
         ];
 
-        for (const dir of moonklabsDirs) {
+        for (const dir of aiwfDirs) {
             await fs.mkdir(dir, { recursive: true });
         }
 
         // Only download manifest on fresh installs
         if (!hasExisting) {
-            logWithSpinner(spinner, 'Moonklabs 프레임워크 파일을 다운로드하는 중...', debugLog);
+            logWithSpinner(spinner, msg.downloading, debugLog);
             // Get the root manifest
             try {
-                const manifestUrl = `${GITHUB_RAW_URL}/${GITHUB_CONTENT_PREFIX}/.moonklabs/00_PROJECT_MANIFEST.md`;
-                await downloadFile(manifestUrl, '.moonklabs/00_PROJECT_MANIFEST.md');
+                const manifestUrl = `${GITHUB_RAW_URL}/${GITHUB_CONTENT_LANGUAGE_PREFIX}/.aiwf/00_PROJECT_MANIFEST.md`;
+                await downloadFile(manifestUrl, '.aiwf/00_PROJECT_MANIFEST.md');
             } catch (error) {
                 // If manifest doesn't exist, that's okay
             }
@@ -255,59 +399,66 @@ async function installMoonklabs(options = {}) {
 
         // Download templates on fresh install
         try {
-            logWithSpinner(spinner, '템플릿 디렉토리를 다운로드 중...', debugLog);
-            await downloadDirectory(`${GITHUB_CONTENT_PREFIX}/.moonklabs/98_PROMPTS`, '.moonklabs/98_PROMPTS', spinner);
-            await downloadDirectory(`${GITHUB_CONTENT_PREFIX}/.moonklabs/99_TEMPLATES`, '.moonklabs/99_TEMPLATES', spinner);
+            logWithSpinner(spinner, msg.downloadingTemplates, debugLog);
+            await downloadDirectory(`${GITHUB_CONTENT_LANGUAGE_PREFIX}/.aiwf/98_PROMPTS`, '.aiwf/98_PROMPTS', spinner, msg);
+            await downloadDirectory(`${GITHUB_CONTENT_LANGUAGE_PREFIX}/.aiwf/99_TEMPLATES`, '.aiwf/99_TEMPLATES', spinner, msg);
         } catch (error) {
-            logWithSpinner(spinner, '템플릿 디렉토리를 찾을 수 없어 건너뜁니다...', debugLog);
+            logWithSpinner(spinner, msg.templatesNotFound, debugLog);
         }
 
         // Always update CLAUDE.md documentation files
-        logWithSpinner(spinner, '문서를 업데이트하는 중...', debugLog);
+        logWithSpinner(spinner, msg.updatingDocs, debugLog);
         const claudeFiles = [
-            '.moonklabs/CLAUDE.md',
-            '.moonklabs/02_REQUIREMENTS/CLAUDE.md',
-            '.moonklabs/03_SPRINTS/CLAUDE.md',
-            '.moonklabs/04_GENERAL_TASKS/CLAUDE.md'
+            '.aiwf/CLAUDE.md',
+            '.aiwf/02_REQUIREMENTS/CLAUDE.md',
+            '.aiwf/03_SPRINTS/CLAUDE.md',
+            '.aiwf/04_GENERAL_TASKS/CLAUDE.md'
         ];
 
         for (const claudeFile of claudeFiles) {
             try {
-                const claudeUrl = `${GITHUB_RAW_URL}/${GITHUB_CONTENT_PREFIX}/${claudeFile}`;
+                const claudeUrl = `${GITHUB_RAW_URL}/${GITHUB_CONTENT_LANGUAGE_PREFIX}/${claudeFile}`;
                 await downloadFile(claudeUrl, claudeFile);
             } catch (error) {
                 // If CLAUDE.md doesn't exist, that's okay
             }
         }
 
-        // Create .claude/commands/moonklabs directory
-        await fs.mkdir('.claude/commands/moonklabs', { recursive: true });
+        // Delete and recreate commands directory
+        const commandsExist = await fs.access(COMMANDS_DIR).then(() => true).catch(() => false);
+
+        if (commandsExist) {
+            logWithSpinner(spinner, msg.deletingOldCommands, debugLog);
+            await fs.rm(COMMANDS_DIR, { recursive: true, force: true });
+        }
+
+        await fs.mkdir(COMMANDS_DIR, { recursive: true });
 
-        // Always update commands
-        logWithSpinner(spinner, 'Moonklabs 명령어를 업데이트하는 중...', debugLog);
+        // Always update commands (clean download)
+        logWithSpinner(spinner, msg.downloadingCommands, debugLog);
         try {
-            await downloadDirectory(`${GITHUB_CONTENT_PREFIX}/.claude/commands/moonklabs`, '.claude/commands/moonklabs', spinner);
+            await downloadDirectory(`${GITHUB_CONTENT_LANGUAGE_PREFIX}/${COMMANDS_DIR}`, COMMANDS_DIR, spinner, msg);
         } catch (error) {
-            logWithSpinner(spinner, '명령어 디렉토리를 찾을 수 없어 건너뜁니다...', debugLog);
+            logWithSpinner(spinner, msg.commandsNotFound, debugLog);
         }
 
         // 2. rules/global 폴더 다운로드 (임시 폴더)
-        let tmpRulesGlobal = '.moonklabs/_tmp_rules_global';
+        let tmpRulesGlobal = '.aiwf/_tmp_rules_global';
         try {
-            logWithSpinner(spinner, 'rules/global 폴더를 다운로드 중...', debugLog);
-            await downloadDirectory(`rules/global`, tmpRulesGlobal, spinner);
+            logWithSpinner(spinner, msg.downloadingRulesGlobal, debugLog);
+            await downloadDirectory(`rules/global`, tmpRulesGlobal, spinner, msg);
         } catch (error) {
-            logWithSpinner(spinner, 'rules/global 폴더를 찾을 수 없어 건너뜁니다...', debugLog);
+            logWithSpinner(spinner, msg.rulesGlobalNotFound, debugLog);
             tmpRulesGlobal = null;
         }
 
         // 2-1. rules/manual 폴더 다운로드 (임시 폴더)
-        let tmpRulesManual = '.moonklabs/_tmp_rules_manual';
+        let tmpRulesManual = '.aiwf/_tmp_rules_manual';
         try {
-            logWithSpinner(spinner, 'rules/manual 폴더를 다운로드 중...', debugLog);
-            await downloadDirectory(`rules/manual`, tmpRulesManual, spinner);
+            logWithSpinner(spinner, msg.downloadingRulesManual, debugLog);
+            await downloadDirectory(`rules/manual`, tmpRulesManual, spinner, msg);
         } catch (error) {
-            logWithSpinner(spinner, 'rules/manual 폴더를 찾을 수 없어 건너뜁니다...', debugLog);
+            logWithSpinner(spinner, msg.rulesManualNotFound, debugLog);
             tmpRulesManual = null;
         }
 
@@ -372,57 +523,57 @@ async function installMoonklabs(options = {}) {
         }
 
         if (hasExisting) {
-            spinner.succeed(chalk.green('✅ Moonklabs 프레임워크가 성공적으로 업데이트되었습니다!'));
-            console.log(chalk.blue('\n🔄 업데이트 내역:'));
-            console.log(chalk.gray('   • .claude/commands/moonklabs/ 내의 명령어'));
-            console.log(chalk.gray('   • 문서 (CLAUDE.md 파일)'));
-            console.log(chalk.green('\n💾 작업 내용은 보존되었습니다:'));
-            console.log(chalk.gray('   • 모든 작업, 스프린트, 및 프로젝트 파일이 변경되지 않음'));
-            console.log(chalk.gray('   • 백업은 *.bak 파일로 만들어짐'));
+            spinner.succeed(chalk.green(msg.updateSuccess));
+            console.log(chalk.blue(`\n${msg.updateHistory}`));
+            console.log(chalk.gray(`   • ${COMMANDS_DIR}${msg.updatedCommands}`));
+            console.log(chalk.gray(`   • ${msg.updatedDocs}`));
+            console.log(chalk.green(`\n${msg.workPreserved}`));
+            console.log(chalk.gray(`   • ${msg.allFilesPreserved}`));
+            console.log(chalk.gray(`   • ${msg.backupCreated}`));
         } else {
-            spinner.succeed(chalk.green('✅ Moonklabs 프레임워크가 성공적으로 설치되었습니다!'));
-            console.log(chalk.blue('\n📁 생성된 구조:'));
-            console.log(chalk.gray('   .moonklabs/              - 프로젝트 관리 루트'));
-            console.log(chalk.gray('   .claude/commands/     - Claude 사용자 명령어'));
-
-            console.log(chalk.green('\n🚀 다음 단계:'));
-            console.log(chalk.white('   1. Claude Code에서 이 프로젝트를 엽니다'));
-            console.log(chalk.white('   2. /project:moonklabs 명령어를 사용하여 프로젝트를 관리하세요'));
-            console.log(chalk.white('   3. /project:moonklabs:initialize를 실행하여 프로젝트를 설정하세요\n'));
-
-            console.log(chalk.blue('\n✨ 시작하려면:'));
-            console.log(chalk.gray('   1. 새 터미널을 열거나 쉘 프로필을 소싱하세요 (예: source ~/.zshrc)'));
-            console.log(chalk.gray(`   2. 다음을 실행하세요: ${chalk.cyan('claude')} 를 실행하여 사용 가능한 명령어를 확인하세요.`));
-            console.log(chalk.gray('\n자세한 내용은 .moonklabs 디렉토리의 문서를 확인하세요.'));
+            spinner.succeed(chalk.green(msg.installSuccess));
+            console.log(chalk.blue(`\n${msg.structureCreated}`));
+            console.log(chalk.gray(`   .aiwf/                - ${msg.aiwfRoot}`));
+            console.log(chalk.gray(`   .claude/commands/     - ${msg.claudeCommands}`));
+
+            console.log(chalk.green(`\n${msg.nextSteps}`));
+            console.log(chalk.white(`   1. ${msg.nextStep1}`));
+            console.log(chalk.white(`   2. ${msg.nextStep2}`));
+            console.log(chalk.white(`   3. ${msg.nextStep3}\n`));
+
+            console.log(chalk.blue(`\n${msg.gettingStarted}`));
+            console.log(chalk.gray(`   1. ${msg.startStep1}`));
+            console.log(chalk.gray(`   2. ${msg.startStep2}`));
+            console.log(chalk.gray(`\n${msg.checkDocs}`));
         }
 
-        console.log(chalk.green('\nEnjoy Moonklabs! 🚀\n'));
+        console.log(chalk.green(msg.enjoy));
 
     } catch (error) {
         if (hasExisting) {
-            spinner.fail(chalk.red('업데이트 실패'));
-            await restoreFromBackup(spinner);
+            spinner.fail(chalk.red(msg.updateFailed));
+            await restoreFromBackup(spinner, msg);
         } else {
-            spinner.fail(chalk.red('설치 실패'));
+            spinner.fail(chalk.red(msg.installFailed));
         }
         console.error(chalk.red(error.message));
         process.exit(1);
     }
 }
 
-async function restoreFromBackup(spinner) {
+async function restoreFromBackup(spinner, msg) {
     if (!BACKUP_DIR) {
         // 가장 최근 backup 폴더 사용
-        const moonklabsDir = '.moonklabs';
-        const dirs = (await fs.readdir(moonklabsDir)).filter(f => f.startsWith('backup_'));
+        const aiwfDir = '.aiwf';
+        const dirs = (await fs.readdir(aiwfDir)).filter(f => f.startsWith('backup_'));
         if (dirs.length === 0) {
-            spinner.fail(chalk.red('복원할 백업 폴더가 없습니다.'));
+            spinner.fail(chalk.red(msg.noBackupFound));
             return;
         }
         dirs.sort();
-        BACKUP_DIR = path.join(moonklabsDir, dirs[dirs.length - 1]);
+        BACKUP_DIR = path.join(aiwfDir, dirs[dirs.length - 1]);
     }
-    spinner.start(chalk.yellow('백업에서 복원 중... '));
+    spinner.start(chalk.yellow(msg.restoringFromBackup));
     try {
         let backupFiles = [];
         try {
@@ -431,16 +582,16 @@ async function restoreFromBackup(spinner) {
             backupFiles = [];
         }
         for (const backup of backupFiles) {
-            // 원래 위치 추정: claude-commands-moonklabs-foo.md.bak -> .claude/commands/moonklabs/foo.md
+            // 원래 위치 추정: claude-commands-aiwf-foo.md.bak -> .claude/commands/aiwf/foo.md
             let originalFile;
-            if (backup.startsWith('moonklabs-')) {
-                // .moonklabs/ 하위
+            if (backup.startsWith('aiwf-')) {
+                // .aiwf/ 하위
                 const rel = backup.replace(/-/g, '/').replace('.bak', '');
                 originalFile = '.' + rel;
-            } else if (backup.startsWith('claude-commands-moonklabs-')) {
-                // .claude/commands/moonklabs/ 하위
-                const rel = backup.replace('claude-commands-moonklabs-', '').replace(/-/g, '/').replace('.bak', '');
-                originalFile = path.join('.claude', 'commands', 'moonklabs', rel);
+            } else if (backup.startsWith('claude-commands-aiwf-')) {
+                // .claude/commands/aiwf/ 하위
+                const rel = backup.replace('claude-commands-aiwf-', '').replace(/-/g, '/').replace('.bak', '');
+                originalFile = path.join(COMMANDS_DIR, rel);
             } else {
                 // 기타
                 originalFile = backup.replace('.bak', '');
@@ -448,21 +599,21 @@ async function restoreFromBackup(spinner) {
             try {
                 await fs.rename(path.join(BACKUP_DIR, backup), originalFile);
             } catch (e) {
-                console.warn(chalk.yellow(`'${backup}' 파일을 복원할 수 없습니다. 수동 확인이 필요합니다.`));
+                console.warn(chalk.yellow(`'${backup}' ${msg.cannotRestore}`));
             }
         }
-        spinner.succeed(chalk.green('성공적으로 복원되었습니다.'));
+        spinner.succeed(chalk.green(msg.restoreSuccess));
     } catch (error) {
-        spinner.fail(chalk.red('복원에 실패했습니다.'));
+        spinner.fail(chalk.red(msg.restoreFailed));
         console.error(error);
     }
 }
 
 program
-    .name('hello-moonklabs')
+    .name('aiwf')
     .version('1.0.1')
-    .description('Moonklabs 프레임워크 설치 프로그램')
-    .option('-f, --force', '프롬프트 없이 강제 설치')
-    .action((options) => installMoonklabs({ ...options, debugLog: true }));
+    .description('AIWF Installer')
+    .option('-f, --force', 'Force install without prompts')
+    .action((options) => installAIWF({ ...options, debugLog: true }));
 
 program.parse(process.argv);

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "aiwf",
-    "version": "0.1.0",
-    "description": "AI Workflow Framework for Moonklabs",
+    "version": "0.3.0",
+    "description": "AI Workflow Framework for Claude Code with multi-language support (Korean/English)",
     "main": "index.js",
     "type": "module",
     "bin": {
@@ -11,21 +11,26 @@
         "test": "echo \"Error: no test specified\" && exit 1"
     },
     "keywords": [
-        "moonklabs",
+        "aiwf",
         "ai",
         "workflow",
-        "framework"
+        "framework",
+        "claude-code",
+        "multilingual",
+        "korean",
+        "english",
+        "project-management"
     ],
     "author": "moonklabs",
     "license": "MIT",
     "repository": {
         "type": "git",
-        "url": "git+https://github.com/moonklabs/aiwf.git"
+        "url": "git+https://github.com/aiwf/aiwf.git"
     },
     "bugs": {
-        "url": "https://github.com/moonklabs/aiwf/issues"
+        "url": "https://github.com/aiwf/aiwf/issues"
     },
-    "homepage": "https://github.com/moonklabs/aiwf#readme",
+    "homepage": "https://github.com/aiwf/aiwf#readme",
     "engines": {
         "node": ">=14.0.0"
     },