aiwf 0.3.21 → 0.3.23

package/src/lib/installer.js

@@ -504,6 +504,22 @@ async function updateCommands(languagePath, spinner, msg, debugLog) {
   } catch (error) {
     logWithSpinner(spinner, 'Agents not found or failed to download', debugLog);
   }
+
+  // Download full .claude directory to include tools, workflow, and any other subfolders
+  logWithSpinner(spinner, 'Downloading full .claude directory (tools, workflow, etc.)...', debugLog);
+  try {
+    await downloadDirectory(
+      `${GITHUB_CONTENT_PREFIX}/${languagePath}/.claude`,
+      '.claude',
+      spinner,
+      msg,
+      languagePath,
+      true // 전체 .claude 폴더 동적 다운로드
+    );
+    logWithSpinner(spinner, 'Successfully downloaded .claude directory', debugLog);
+  } catch (error) {
+    logWithSpinner(spinner, `Failed to download full .claude directory: ${error.message}`, debugLog);
+  }
 }
 
 /**
@@ -877,6 +893,221 @@ async function offerReinstallationOptions(validationResults, language) {
   return response.action;
 }
 
+/**
+ * 사용자 설치 옵션 선택
+ * @param {Object} msg - 지역화된 메시지
+ * @returns {Promise<Array>} 선택된 설치 옵션 목록
+ */
+async function selectInstallationOptions(msg) {
+  console.log(chalk.cyan(`\n${msg.installationOptions}`));
+
+  const installOptions = [
+    {
+      title: msg.aiwfDocs,
+      value: 'aiwf-docs',
+      description: 'AIWF 문서 폴더'
+    },
+    {
+      title: msg.claudeCodeCommands,
+      value: 'claude-code-commands',
+      description: 'Claude Code 명령어 및 에이전트'
+    },
+    {
+      title: msg.windsurfRules,
+      value: 'windsurf-rules',
+      description: 'Windsurf 규칙 파일'
+    },
+    {
+      title: msg.cursorRules,
+      value: 'cursor-rules',
+      description: 'Cursor 규칙 파일'
+    }
+  ];
+
+  // 1단계: 전체 설치 vs 개별 선택
+  const installTypeResponse = await prompts({
+    type: 'select',
+    name: 'installType',
+    message: msg.installationOptions || '설치 옵션을 선택하세요:',
+    choices: [
+      {
+        title: msg.selectAll || '✅ 모든 항목 설치 (권장)',
+        value: 'all',
+        description: '모든 AIWF 컴포넌트를 설치합니다'
+      },
+      {
+        title: '🎯 개별 항목 선택',
+        value: 'custom',
+        description: '원하는 항목만 선택하여 설치합니다'
+      }
+    ]
+  });
+
+  // 취소된 경우
+  if (!installTypeResponse.installType) {
+    console.log(chalk.yellow(msg.noOptionsSelected || '설치가 취소되었습니다.'));
+    process.exit(0);
+  }
+
+  // 전체 설치 선택
+  if (installTypeResponse.installType === 'all') {
+    return installOptions.map(opt => opt.value);
+  }
+
+  // 2단계: 개별 항목 선택
+  const customResponse = await prompts({
+    type: 'multiselect',
+    name: 'selectedOptions',
+    message: '설치할 항목을 선택하세요 (스페이스로 선택/해제, 엔터로 확인):',
+    choices: installOptions,
+    hint: '↑↓ 이동, 스페이스 선택/해제, 엔터 확인',
+    instructions: false
+  });
+
+  // 취소되거나 아무것도 선택하지 않은 경우
+  if (!customResponse.selectedOptions || customResponse.selectedOptions.length === 0) {
+    console.log(chalk.yellow(msg.noOptionsSelected || '선택된 항목이 없습니다.'));
+    process.exit(0);
+  }
+
+  return customResponse.selectedOptions;
+}
+
+/**
+ * 선택된 옵션별 설치 실행
+ * @param {Array} selectedOptions - 선택된 설치 옵션들
+ * @param {string} languagePath - 언어 경로
+ * @param {Object} msg - 지역화된 메시지
+ * @param {boolean} debugLog - 디버그 로그 여부
+ */
+async function installSelectedOptions(selectedOptions, languagePath, msg, debugLog) {
+  for (const option of selectedOptions) {
+    const spinner = ora(`${msg.installingOption}${option}...`).start();
+
+    try {
+      switch (option) {
+        case 'aiwf-docs':
+          await installAIWFDocs(languagePath, debugLog);
+          break;
+        case 'claude-code-commands':
+          await installClaudeCodeCommands(languagePath, debugLog);
+          break;
+        case 'windsurf-rules':
+          await installWindsurfRules(debugLog);
+          break;
+        case 'cursor-rules':
+          await installCursorRules(debugLog);
+          break;
+        default:
+          spinner.warn(`Unknown option: ${option}`);
+          continue;
+      }
+
+      spinner.succeed(`${msg.optionInstalled}${option}`);
+    } catch (error) {
+      spinner.fail(`Failed to install ${option}: ${error.message}`);
+      if (debugLog) {
+        console.error(error);
+      }
+    }
+  }
+}
+
+/**
+ * AIWF 문서 설치
+ */
+async function installAIWFDocs(languagePath, debugLog) {
+  await createDirectoryStructure();
+  const spinner = ora('Downloading AIWF files...').start();
+  const msg = {
+    downloading: 'Downloading AIWF documentation...',
+    downloadingTemplates: 'Downloading templates...',
+    templatesNotFound: 'Templates not found'
+  };
+
+  try {
+    // 매니페스트 다운로드
+    await downloadManifest(languagePath, spinner, msg, debugLog);
+
+    // 전체 .aiwf 디렉토리 다운로드
+    await downloadTemplates(languagePath, spinner, msg, debugLog);
+
+    spinner.succeed('AIWF documentation installed successfully');
+  } catch (error) {
+    spinner.fail('Failed to install AIWF documentation');
+    if (debugLog) {
+      console.error(error);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Claude Code 명령어 설치
+ */
+async function installClaudeCodeCommands(languagePath, debugLog) {
+  const GITHUB_CONTENT_LANGUAGE_PREFIX = `${GITHUB_CONTENT_PREFIX}/${languagePath}`;
+  const dummySpinner = null;
+  const dummyMsg = { downloadingCommands: 'Downloading Claude Code commands...' };
+  await updateCommands(languagePath, dummySpinner, dummyMsg, debugLog);
+}
+
+/**
+ * Windsurf 규칙 설치
+ */
+async function installWindsurfRules(debugLog) {
+  const spinner = ora('Installing Windsurf rules...').start();
+  const msg = {
+    checkingExistingTools: 'Checking existing tools...',
+    foundExistingCursor: 'Found existing Cursor rules',
+    foundExistingWindsurf: 'Found existing Windsurf rules',
+    backingUpToolFiles: 'Backing up tool files...',
+    toolBackupCreated: 'Tool backup created',
+    rulesGlobalNotFound: 'Rules global not found',
+    rulesManualNotFound: 'Rules manual not found',
+    toolRulesInstalled: 'Tool rules installed successfully'
+  };
+
+  try {
+    await downloadAndProcessRules(spinner, msg, debugLog);
+    spinner.succeed('Windsurf rules installed successfully');
+  } catch (error) {
+    spinner.fail('Failed to install Windsurf rules');
+    if (debugLog) {
+      console.error(error);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Cursor 규칙 설치
+ */
+async function installCursorRules(debugLog) {
+  const spinner = ora('Installing Cursor rules...').start();
+  const msg = {
+    checkingExistingTools: 'Checking existing tools...',
+    foundExistingCursor: 'Found existing Cursor rules',
+    foundExistingWindsurf: 'Found existing Windsurf rules',
+    backingUpToolFiles: 'Backing up tool files...',
+    toolBackupCreated: 'Tool backup created',
+    rulesGlobalNotFound: 'Rules global not found',
+    rulesManualNotFound: 'Rules manual not found',
+    toolRulesInstalled: 'Tool rules installed successfully'
+  };
+
+  try {
+    await downloadAndProcessRules(spinner, msg, debugLog);
+    spinner.succeed('Cursor rules installed successfully');
+  } catch (error) {
+    spinner.fail('Failed to install Cursor rules');
+    if (debugLog) {
+      console.error(error);
+    }
+    throw error;
+  }
+}
+
 /**
  * Main installation function
  * @param {Object} options - Installation options
@@ -894,7 +1125,6 @@ export async function installAIWF(options = {}) {
 
   // Set language path
   const languagePath = getInstallationLanguagePath(selectedLanguage);
-  const GITHUB_CONTENT_LANGUAGE_PREFIX = `${GITHUB_CONTENT_PREFIX}/${languagePath}`;
 
   // Check existing installation
   const hasExisting = await checkExistingInstallation();
@@ -903,11 +1133,9 @@ export async function installAIWF(options = {}) {
   let projectBackupDir = null;
 
   if (hasExisting) {
-
     installDecision = await handleExistingInstallation(msg, options);
-
     if (!installDecision.continue) return;
-    
+
     // If reinstalling and preserving project, backup project files
     if (installDecision.installType === 'reinstall' && installDecision.preserveProject) {
       const { hasProject, projectFiles } = await checkExistingProject();
@@ -917,120 +1145,112 @@ export async function installAIWF(options = {}) {
     }
   }
 
-  const spinner = ora(msg.fetching).start();
-
-  try {
-    // Create directory structure
-    await createDirectoryStructure();
-
-    // Download manifest (fresh installs only or complete reinstall)
-    if (!hasExisting || installDecision.installType === 'reinstall') {
-      await downloadManifest(languagePath, spinner, msg, debugLog);
-    }
-
-    // Download templates (fresh installs and complete reinstall only)
-    if (!hasExisting || installDecision.installType === 'reinstall') {
-      await downloadTemplates(languagePath, spinner, msg, debugLog);
-    }
-
-    // Update documentation (fresh installs and complete reinstall only)
-    if (!hasExisting || installDecision.installType === 'reinstall') {
-      await updateDocumentation(languagePath, spinner, msg, debugLog);
-    }
+  // 설치 옵션 선택
+  let selectedOptions = ['aiwf-docs', 'claude-code-commands', 'windsurf-rules', 'cursor-rules'];
+
+  if (options.preselectedOptions) {
+    // CLI에서 미리 선택된 옵션들을 사용
+    selectedOptions = options.preselectedOptions;
+  } else if (!options.force && !options.interactive) {
+    // 기본적으로는 대화형 선택을 사용
+    selectedOptions = await selectInstallationOptions(msg);
+  } else if (options.interactive) {
+    // --interactive 플래그가 명시적으로 설정된 경우
+    selectedOptions = await selectInstallationOptions(msg);
+  }
 
-    // Update commands
-    await updateCommands(languagePath, spinner, msg, debugLog);
+  console.log(chalk.blue(`\n설치할 옵션: ${selectedOptions.join(', ')}`));
 
-    // Download and process rules
-    const toolDirStatus = await downloadAndProcessRules(spinner, msg, debugLog);
+  try {
+    // 선택된 옵션들을 설치
+    await installSelectedOptions(selectedOptions, languagePath, msg, debugLog);
 
     // Restore project files if needed
     if (projectBackupDir) {
       await restoreProjectFiles(projectBackupDir, msg);
     }
 
-    // Success
+    // Success message
     if (hasExisting && installDecision.installType === 'update') {
-      spinner.succeed(chalk.green(msg.updateSuccess));
+      console.log(chalk.green(`\n✅ ${msg.updateSuccess}`));
     } else {
-      spinner.succeed(chalk.green(msg.installSuccess));
+      console.log(chalk.green(`\n✅ ${msg.installSuccess}`));
     }
 
     // Display summary
     displaySummary(hasExisting, msg);
 
-    // Run validation
+    // Run validation based on selected options
     console.log(
       chalk.blue('\n🔍 Installation Validation / 설치 검증을 시작합니다...')
     );
-    const selectedTools = ['claude-code', 'cursor', 'windsurf'];
-    const validationResults = await validateInstallation(
-      selectedTools,
-      selectedLanguage
-    );
-    displaySpecCompliantValidationResults(validationResults, selectedLanguage);
 
-    // Handle partial failures
-    if (validationResults.failed.length > 0) {
-      const action = await offerReinstallationOptions(
-        validationResults,
+    // Map selected options to validation tools
+    const validationTools = [];
+    if (selectedOptions.includes('claude-code-commands')) {
+      validationTools.push('claude-code');
+    }
+    if (selectedOptions.includes('cursor-rules')) {
+      validationTools.push('cursor');
+    }
+    if (selectedOptions.includes('windsurf-rules')) {
+      validationTools.push('windsurf');
+    }
+
+    if (validationTools.length > 0) {
+      const validationResults = await validateInstallation(
+        validationTools,
         selectedLanguage
       );
+      displaySpecCompliantValidationResults(validationResults, selectedLanguage);
 
-      if (action === 'reinstall') {
-        console.log(
-          chalk.blue('\n🔄 재설치를 시작합니다... / Starting reinstallation...')
-        );
-        // Retry installation once
-        if (!options.isRetry) {
-          return await installAIWF({ ...options, isRetry: true });
-        }
-      } else if (action === 'rollback') {
-        console.log(
-          chalk.blue('\n↩️  실패한 도구를 롤백합니다... / Rolling back failed tools...')
-        );
-
-        // Rollback failed tools
-        const failedTools = validationResults.failed.map(({ tool }) => tool);
-        const backupDir = getCurrentBackupDir();
-        let rollbackResults = {};
-
-        for (const tool of failedTools) {
-          if (backupDir) {
-            const rollbackResult = await rollbackTool(
-              tool,
-              backupDir,
-              selectedLanguage
-            );
-            rollbackResults[tool] = rollbackResult;
-          }
-        }
-
-        // Re-validate after rollback
-        console.log(
-          chalk.blue('\n🔍 롤백 후 재검증... / Re-validating after rollback...')
-        );
-        const postRollbackValidation = await validateInstallation(
-          selectedTools,
-          selectedLanguage
-        );
-        displaySpecCompliantValidationResults(
-          postRollbackValidation,
+      // Handle partial failures
+      if (validationResults.failed.length > 0) {
+        const action = await offerReinstallationOptions(
+          validationResults,
           selectedLanguage
         );
 
-        // Rollback summary
-        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}`));
+        if (action === 'reinstall') {
+          console.log(
+            chalk.blue('\n🔄 재설치를 시작합니다... / Starting reinstallation...')
+          );
+          // Retry installation once
+          if (!options.isRetry) {
+            return await installAIWF({ ...options, isRetry: true });
           }
+        } else if (action === 'rollback') {
+          console.log(
+            chalk.blue('\n↩️  실패한 도구를 롤백합니다... / Rolling back failed tools...')
+          );
+
+          // Rollback failed tools
+          const failedTools = validationResults.failed.map(({ tool }) => tool);
+          const backupDir = getCurrentBackupDir();
+
+          for (const tool of failedTools) {
+            if (backupDir) {
+              await rollbackTool(
+                tool,
+                backupDir,
+                selectedLanguage
+              );
+            }
+          }
+
+          // Re-validate after rollback
+          console.log(
+            chalk.blue('\n🔍 롤백 후 재검증... / Re-validating after rollback...')
+          );
+          const postRollbackValidation = await validateInstallation(
+            validationTools,
+            selectedLanguage
+          );
+          displaySpecCompliantValidationResults(postRollbackValidation, selectedLanguage);
         }
       }
+    } else {
+      console.log(chalk.yellow('\n⚠️ 검증할 도구가 선택되지 않았습니다.'));
     }
 
     console.log(chalk.green(msg.enjoy));

package/src/utils/messages.js

@@ -77,6 +77,18 @@ export const messages = {
     toolBackupCreated: '도구 파일 백업이 생성되었습니다',
     installingToolRules: '도구 규칙을 설치하는 중...',
     toolRulesInstalled: '도구 규칙이 성공적으로 설치되었습니다',
+
+    // 설치 옵션 관련
+    installationOptions: 'AIWF 설치 옵션을 선택하세요:',
+    aiwfDocs: 'AIWF 문서 폴더 (.aiwf/docs)',
+    claudeCodeCommands: 'Claude Code 명령어 및 에이전트',
+    windsurfRules: 'Windsurf 규칙 파일',
+    cursorRules: 'Cursor 규칙 파일',
+    selectAll: '모든 옵션 선택',
+    installSelected: '선택한 항목들을 설치하시겠습니까?',
+    installingOption: '설치 중: ',
+    optionInstalled: '완료: ',
+    noOptionsSelected: '선택된 옵션이 없습니다.',
   },
   en: {
     welcome: '\n🎉 Welcome to AIWF!\n',
@@ -153,6 +165,18 @@ export const messages = {
     toolBackupCreated: 'Tool files backup created',
     installingToolRules: 'Installing tool rules...',
     toolRulesInstalled: 'Tool rules installed successfully',
+
+    // Installation options
+    installationOptions: 'Select AIWF installation options:',
+    aiwfDocs: 'AIWF Documentation folder (.aiwf/docs)',
+    claudeCodeCommands: 'Claude Code commands and agents',
+    windsurfRules: 'Windsurf rules files',
+    cursorRules: 'Cursor rules files',
+    selectAll: 'Select all options',
+    installSelected: 'Install selected items?',
+    installingOption: 'Installing: ',
+    optionInstalled: 'Completed: ',
+    noOptionsSelected: 'No options selected.',
   }
 };
 

package/src/DEPENDENCY_MAP.md

@@ -1,90 +0,0 @@
-# AIWF 모듈 의존성 매트릭스
-
-## 📊 CLI 명령어별 의존성
-
-| 명령어 | 직접 의존성 | 간접 의존성 | 특수 사용 |
-|--------|-------------|-------------|-----------|
-| `aiwf install` | installer.js | backup-manager.js, file-downloader.js, rollback-manager.js, validator.js | - |
-| `aiwf persona` | persona.js, ai-persona-manager.js | context-engine.js, metrics-collector.js, task-analyzer.js, token-optimizer.js | - |
-| `aiwf compress` | compress.js, resource-loader.js | - | - |
-| `aiwf token` | token.js, resource-loader.js | - | - |
-| `aiwf evaluate` | evaluate.js, resource-loader.js | - | - |
-| `aiwf state` | state.js | - | - |
-| `aiwf create-project` | create-project.js, resource-loader.js | - | - |
-| `aiwf ai-tool` | ai-tool.js | - | - |
-| `aiwf sprint-task` | sprint-task.js | - | - |
-| `aiwf sprint` | sprint-independent.js | - | - |
-| `aiwf yolo-config` | yolo-config.js | - | - |
-| `aiwf checkpoint` | checkpoint-manager.js | - | ⚠️ YOLO 전용 |
-| `aiwf-checkpoint` | checkpoint-manager.js | - | ⚠️ YOLO 전용 |
-| `aiwf cache` | cache-cli.js | template-cache-system.js, offline-detector.js, template-downloader.js, template-version-manager.js | - |
-| `aiwf github` | github-integration.js | state/state-index.js | - |
-| `YOLO 모드` | engineering-guard.js | - | ⚠️ 동적 import |
-
-## 🏗️ 모듈 분류
-
-### 🔧 핵심 유틸리티 (삭제 금지)
-- **paths.js** - 경로 관리 (8곳에서 사용)
-- **messages.js** - 다국어 메시지 시스템 (5곳에서 사용)
-- **language-utils.js** - 언어 설정 관리 (3곳에서 사용)
-
-### 🚀 YOLO 시스템 (삭제 금지)
-- **engineering-guard.js** - 오버엔지니어링 방지 ⚠️ 동적 로드
-- **checkpoint-manager.js** - 체크포인트 관리
-
-### 🎯 명령어별 전용 모듈
-
-#### AI Persona 시스템
-- **ai-persona-manager.js** → persona 명령어
-- **context-engine.js** → ai-persona-manager가 사용
-- **metrics-collector.js** → ai-persona-manager가 사용  
-- **task-analyzer.js** → ai-persona-manager가 사용
-- **token-optimizer.js** → context-engine이 사용
-
-#### 설치/백업 시스템
-- **installer.js** → install 명령어
-- **backup-manager.js** → installer가 사용
-- **file-downloader.js** → installer가 사용
-- **rollback-manager.js** → installer가 사용
-- **validator.js** → installer가 사용
-
-#### 캐시 시스템
-- **template-cache-system.js** → cache 명령어
-- **offline-detector.js** → cache 명령어
-- **template-downloader.js** → cache 명령어
-- **template-version-manager.js** → cache 명령어
-
-#### GitHub 통합
-- **github-integration.js** → github 명령어
-- **state/state-index.js** → github-integration이 사용
-
-#### 공통 리소스
-- **resource-loader.js** → 5개 명령어에서 사용
-
-## ⚠️ 삭제 위험 모듈
-
-### 동적 로드 모듈 (CLI에서 직접 참조되지 않음)
-- **engineering-guard.js** - YOLO 템플릿에서 `import()`로 로드
-- **state/priority-calculator.js** - github-integration에서 사용
-- **state/task-scanner.js** - github-integration에서 사용
-
-### 간접 의존성 모듈
-- AI Persona 시스템의 하위 모듈들
-- 설치 시스템의 백업/복구 모듈들
-
-## 🚨 삭제하기 전 확인사항
-
-1. **이 파일에서 모듈 위치 확인**
-2. **`@warning 삭제 금지` 주석 확인**
-3. **YOLO 전용 모듈인지 확인**
-4. **동적 import 사용 여부 확인**
-5. **간접 의존성 체인 확인**
-
-## 📁 미사용 모듈 (삭제 가능)
-
-현재 완전히 미사용되는 모듈은 없습니다. 모든 모듈이 직간접적으로 CLI 시스템에서 사용됩니다.
-
----
-
-**마지막 업데이트**: 2024-01-27  
-**검증 방법**: `grep -r "모듈명" src/` 으로 사용처 확인