aiwf 0.3.18 → 0.3.20

package/src/lib/installer.js

@@ -34,7 +34,6 @@ import {
 import {
   FILES,
   TOOL_DIRS,
-  TEMP_DIRS,
   AIWF_DIRS,
   BASE_DIRS,
   getAllAiwfDirectories,
@@ -507,14 +506,112 @@ async function updateCommands(languagePath, spinner, msg, debugLog) {
   }
 }
 
+/**
+ * Check if tool directories exist and handle them
+ * @param {Object} spinner - Ora spinner instance
+ * @param {Object} msg - Localized messages
+ * @param {boolean} debugLog - Debug mode flag
+ * @returns {Promise<Object>} Directory status info
+ */
+async function checkAndHandleExistingToolDirs(spinner, msg, debugLog) {
+  const toolDirStatus = {
+    cursor: {
+      exists: false,
+      hadFiles: false,
+      backedUp: false
+    },
+    windsurf: {
+      exists: false,
+      hadFiles: false,
+      backedUp: false
+    }
+  };
+
+  // Check Cursor directory
+  try {
+    await fs.access(TOOL_DIRS.CURSOR_RULES);
+    toolDirStatus.cursor.exists = true;
+    
+    const cursorFiles = await fs.readdir(TOOL_DIRS.CURSOR_RULES);
+    const mdcFiles = cursorFiles.filter(file => file.endsWith('.mdc'));
+    
+    if (mdcFiles.length > 0) {
+      toolDirStatus.cursor.hadFiles = true;
+      logWithSpinner(spinner, `${msg.foundExistingCursor} (${mdcFiles.length} files)`, debugLog);
+      
+      // Backup existing files
+      logWithSpinner(spinner, msg.backingUpToolFiles, debugLog);
+      const backupDir = path.join(TOOL_DIRS.CURSOR_RULES, `backup_${Date.now()}`);
+      await fs.mkdir(backupDir, { recursive: true });
+      
+      for (const file of mdcFiles) {
+        const srcPath = path.join(TOOL_DIRS.CURSOR_RULES, file);
+        const backupPath = path.join(backupDir, file);
+        await fs.copyFile(srcPath, backupPath);
+      }
+      
+      toolDirStatus.cursor.backedUp = true;
+      logWithSpinner(spinner, `${msg.toolBackupCreated}: ${backupDir}`, debugLog);
+      
+      // Remove existing files
+      for (const file of mdcFiles) {
+        await fs.unlink(path.join(TOOL_DIRS.CURSOR_RULES, file));
+      }
+    }
+  } catch (error) {
+    // Directory doesn't exist, that's fine
+    logWithSpinner(spinner, `Cursor rules directory not found, will create new`, debugLog);
+  }
+
+  // Check Windsurf directory
+  try {
+    await fs.access(TOOL_DIRS.WINDSURF_RULES);
+    toolDirStatus.windsurf.exists = true;
+    
+    const windsurfFiles = await fs.readdir(TOOL_DIRS.WINDSURF_RULES);
+    const mdFiles = windsurfFiles.filter(file => file.endsWith('.md'));
+    
+    if (mdFiles.length > 0) {
+      toolDirStatus.windsurf.hadFiles = true;
+      logWithSpinner(spinner, `${msg.foundExistingWindsurf} (${mdFiles.length} files)`, debugLog);
+      
+      // Backup existing files
+      logWithSpinner(spinner, msg.backingUpToolFiles, debugLog);
+      const backupDir = path.join(TOOL_DIRS.WINDSURF_RULES, `backup_${Date.now()}`);
+      await fs.mkdir(backupDir, { recursive: true });
+      
+      for (const file of mdFiles) {
+        const srcPath = path.join(TOOL_DIRS.WINDSURF_RULES, file);
+        const backupPath = path.join(backupDir, file);
+        await fs.copyFile(srcPath, backupPath);
+      }
+      
+      toolDirStatus.windsurf.backedUp = true;
+      logWithSpinner(spinner, `${msg.toolBackupCreated}: ${backupDir}`, debugLog);
+      
+      // Remove existing files
+      for (const file of mdFiles) {
+        await fs.unlink(path.join(TOOL_DIRS.WINDSURF_RULES, file));
+      }
+    }
+  } catch (error) {
+    // Directory doesn't exist, that's fine
+    logWithSpinner(spinner, `Windsurf rules directory not found, will create new`, debugLog);
+  }
+
+  return toolDirStatus;
+}
+
 /**
  * Download and process rules
  * @param {Object} spinner - Ora spinner instance
-{{ ... }}
  * @param {Object} msg - Localized messages
  * @param {boolean} debugLog - Debug mode flag
  */
 async function downloadAndProcessRules(spinner, msg, debugLog) {
+  // Check and handle existing tool directories first
+  logWithSpinner(spinner, msg.checkingExistingTools, debugLog);
+  const toolDirStatus = await checkAndHandleExistingToolDirs(spinner, msg, debugLog);
   // Try to download from GitHub first, fallback to local files
   const tmpRulesGlobal = path.join(os.tmpdir(), 'aiwf-rules-global');
   const tmpRulesManual = path.join(os.tmpdir(), 'aiwf-rules-manual');
@@ -670,6 +767,32 @@ async function downloadAndProcessRules(spinner, msg, debugLog) {
   } catch (error) {
     logWithSpinner(spinner, `No rules/manual directory found`, debugLog);
   }
+
+  // Success message for tool rules installation
+  logWithSpinner(spinner, msg.toolRulesInstalled, debugLog);
+
+  // Display installation results for tool directories
+  if (toolDirStatus.cursor.backedUp || toolDirStatus.windsurf.backedUp) {
+    console.log(chalk.cyan(`\n📂 Tool Directory Installation Results:`));
+    
+    if (toolDirStatus.cursor.backedUp) {
+      console.log(chalk.yellow(`   • Cursor: Existing rules backed up and replaced`));
+    } else if (toolDirStatus.cursor.exists) {
+      console.log(chalk.green(`   • Cursor: Rules installed (directory was empty)`));
+    } else {
+      console.log(chalk.green(`   • Cursor: Rules installed (new directory)`));
+    }
+    
+    if (toolDirStatus.windsurf.backedUp) {
+      console.log(chalk.yellow(`   • Windsurf: Existing rules backed up and replaced`));
+    } else if (toolDirStatus.windsurf.exists) {
+      console.log(chalk.green(`   • Windsurf: Rules installed (directory was empty)`));
+    } else {
+      console.log(chalk.green(`   • Windsurf: Rules installed (new directory)`));
+    }
+  }
+
+  return toolDirStatus;
 }
 
 /**
@@ -819,7 +942,7 @@ export async function installAIWF(options = {}) {
     await updateCommands(languagePath, spinner, msg, debugLog);
 
     // Download and process rules
-    await downloadAndProcessRules(spinner, msg, debugLog);
+    const toolDirStatus = await downloadAndProcessRules(spinner, msg, debugLog);
 
     // Restore project files if needed
     if (projectBackupDir) {

package/src/lib/validator.js

@@ -3,322 +3,17 @@ import path from 'path';
 import chalk from 'chalk';
 import { TOOL_DIRS, AIWF_DIRS, FILES } from '../utils/paths.js';
 
-// Essential files configuration for each tool
-const ESSENTIAL_FILES = {
-  claudeCode: {
-    baseDir: TOOL_DIRS.CLAUDE_COMMANDS,
-    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: TOOL_DIRS.GEMINI_PROMPTS,
-    requiredFiles: ['README.md'],
-    minFileCount: 1,
-    description: 'Gemini-CLI Prompts'
-  },
-  cursor: {
-    baseDir: TOOL_DIRS.CURSOR_RULES,
-    requiredFiles: [],
-    minFileCount: 2,
-    fileExtension: '.mdc',
-    description: 'Cursor IDE Rules'
-  },
-  windsurf: {
-    baseDir: TOOL_DIRS.WINDSURF_RULES,
-    requiredFiles: [],
-    minFileCount: 2,
-    fileExtension: '.md',
-    description: 'Windsurf IDE Rules'
-  },
-  aiwf: {
-    baseDir: AIWF_DIRS.ROOT,
-    requiredFiles: ['CLAUDE.md', '00_PROJECT_MANIFEST.md'],
-    minFileCount: 2,
-    description: 'AIWF Core Structure'
+// Validation constants
+const VALIDATION_CONSTANTS = {
+  MIN_FILE_SIZE: 10,
+  MIN_RULE_FILE_SIZE: 50,
+  MIN_FILE_COUNT: {
+    CURSOR_MDC: 2,
+    WINDSURF_MD: 2,
+    CLAUDE_COMMANDS: 4
   }
 };
 
-/**
- * Validate tool installation based on configuration
- * @param {Object} config - Tool configuration
- * @returns {Promise<Object>} Validation results
- */
-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. Check directory exists
-    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. Get file list
-    const actualFiles = await fs.readdir(config.baseDir);
-    results.checks.fileCount = actualFiles.length;
-
-    // 3. Check required files
-    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;
-
-          // Validate file size (minimum 10 bytes)
-          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. File extension validation (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;
-      }
-
-      // Validate file sizes for extension files
-      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 files should be at least 50 bytes
-            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. Minimum file count validation
-    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;
-}
-
-/**
- * Validate Claude Code installation
- * @returns {Promise<Object>} Validation results
- */
-export async function validateClaudeInstall() {
-  return await validateToolInstallation(ESSENTIAL_FILES.claudeCode);
-}
-
-/**
- * Validate Gemini CLI installation
- * @returns {Promise<Object>} Validation results
- */
-export async function validateGeminiInstall() {
-  return await validateToolInstallation(ESSENTIAL_FILES.geminiCLI);
-}
-
-/**
- * Validate Cursor installation
- * @returns {Promise<Object>} Validation results
- */
-export async function validateCursorInstall() {
-  return await validateToolInstallation(ESSENTIAL_FILES.cursor);
-}
-
-/**
- * Validate Windsurf installation
- * @returns {Promise<Object>} Validation results
- */
-export async function validateWindsurfInstall() {
-  return await validateToolInstallation(ESSENTIAL_FILES.windsurf);
-}
-
-/**
- * Validate AIWF Core installation
- * @returns {Promise<Object>} Validation results
- */
-export async function validateAIWFCore() {
-  return await validateToolInstallation(ESSENTIAL_FILES.aiwf);
-}
-
-/**
- * Validate installation with detailed results
- * @returns {Promise<Object>} Detailed validation results
- */
-export async function validateInstallationDetailed() {
-  const validationResults = {
-    overall: {
-      success: true,
-      toolsChecked: 0,
-      toolsPassed: 0,
-      toolsFailed: 0,
-      totalIssues: 0
-    },
-    tools: {}
-  };
-
-  // Always validate AIWF core
-  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;
-  }
-
-  // Validate all tools
-  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;
-}
-
-/**
- * Enhanced installation validation with tool selection
- * @param {Array|null} selectedTools - Tools to validate
- * @param {string} language - Language code
- * @returns {Promise<Object>} Validation results
- */
-export async function validateInstallationEnhanced(selectedTools = null, language = 'en') {
-  const validationResults = {
-    overall: {
-      success: true,
-      toolsChecked: 0,
-      toolsPassed: 0,
-      toolsFailed: 0,
-      totalIssues: 0
-    },
-    tools: {}
-  };
-
-  // Always validate AIWF core
-  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;
-  }
-
-  // Determine tools to validate
-  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;
-}
 
 /**
  * Simplified validation with clean interface
@@ -440,6 +135,16 @@ async function validateClaudeCode() {
       if (!exists) {
         return { success: false, reason: `Missing file: ${filePath}` };
       }
+      
+      // Check file size
+      try {
+        const stats = await fs.stat(filePath);
+        if (stats.size < VALIDATION_CONSTANTS.MIN_FILE_SIZE) {
+          return { success: false, reason: `File ${fileName} is too small (${stats.size} bytes)` };
+        }
+      } catch (error) {
+        return { success: false, reason: `Cannot read file ${fileName}: ${error.message}` };
+      }
     }
 
     return { success: true };
@@ -485,6 +190,36 @@ async function validateCursorTool() {
       return { success: false, reason: `Missing Cursor rules directory: ${TOOL_DIRS.CURSOR_RULES}` };
     }
 
+    // Enhanced validation: Check file count and types
+    const files = await fs.readdir(TOOL_DIRS.CURSOR_RULES);
+    const mdcFiles = files.filter(file => file.endsWith('.mdc'));
+    
+    if (mdcFiles.length < VALIDATION_CONSTANTS.MIN_FILE_COUNT.CURSOR_MDC) {
+      return { 
+        success: false, 
+        reason: `Cursor rules: Expected at least ${VALIDATION_CONSTANTS.MIN_FILE_COUNT.CURSOR_MDC} .mdc files, found ${mdcFiles.length}` 
+      };
+    }
+
+    // Validate file sizes
+    for (const file of mdcFiles) {
+      const filePath = path.join(TOOL_DIRS.CURSOR_RULES, file);
+      try {
+        const stats = await fs.stat(filePath);
+        if (stats.size < VALIDATION_CONSTANTS.MIN_RULE_FILE_SIZE) {
+          return { 
+            success: false, 
+            reason: `Cursor rules file ${file} is too small (${stats.size} bytes, minimum ${VALIDATION_CONSTANTS.MIN_RULE_FILE_SIZE})` 
+          };
+        }
+      } catch (error) {
+        return { 
+          success: false, 
+          reason: `Cannot read Cursor rules file ${file}: ${error.message}` 
+        };
+      }
+    }
+
     return { success: true };
   } catch (error) {
     return { success: false, reason: `Cursor validation error: ${error.message}` };
@@ -505,6 +240,36 @@ async function validateWindsurfTool() {
       return { success: false, reason: `Missing Windsurf rules directory: ${TOOL_DIRS.WINDSURF_RULES}` };
     }
 
+    // Enhanced validation: Check file count and types
+    const files = await fs.readdir(TOOL_DIRS.WINDSURF_RULES);
+    const mdFiles = files.filter(file => file.endsWith('.md'));
+    
+    if (mdFiles.length < VALIDATION_CONSTANTS.MIN_FILE_COUNT.WINDSURF_MD) {
+      return { 
+        success: false, 
+        reason: `Windsurf rules: Expected at least ${VALIDATION_CONSTANTS.MIN_FILE_COUNT.WINDSURF_MD} .md files, found ${mdFiles.length}` 
+      };
+    }
+
+    // Validate file sizes
+    for (const file of mdFiles) {
+      const filePath = path.join(TOOL_DIRS.WINDSURF_RULES, file);
+      try {
+        const stats = await fs.stat(filePath);
+        if (stats.size < VALIDATION_CONSTANTS.MIN_RULE_FILE_SIZE) {
+          return { 
+            success: false, 
+            reason: `Windsurf rules file ${file} is too small (${stats.size} bytes, minimum ${VALIDATION_CONSTANTS.MIN_RULE_FILE_SIZE})` 
+          };
+        }
+      } catch (error) {
+        return { 
+          success: false, 
+          reason: `Cannot read Windsurf rules file ${file}: ${error.message}` 
+        };
+      }
+    }
+
     return { success: true };
   } catch (error) {
     return { success: false, reason: `Windsurf validation error: ${error.message}` };

package/src/utils/messages.js

@@ -69,7 +69,14 @@ export const messages = {
     checkingInstallation: 'AIWF 설치 상태를 확인하는 중...',
     creatingDirectories: 'AIWF 디렉토리 구조를 생성하는 중...',
     restoringBackup: '백업에서 파일을 복원하는 중...',
-    backupRestored: '{count}개 파일이 복원되었습니다'
+    backupRestored: '{count}개 파일이 복원되었습니다',
+    checkingExistingTools: '기존 도구 디렉토리를 확인하는 중...',
+    foundExistingCursor: 'Cursor 규칙 파일이 발견되었습니다',
+    foundExistingWindsurf: 'Windsurf 규칙 파일이 발견되었습니다',
+    backingUpToolFiles: '기존 도구 파일을 백업하는 중...',
+    toolBackupCreated: '도구 파일 백업이 생성되었습니다',
+    installingToolRules: '도구 규칙을 설치하는 중...',
+    toolRulesInstalled: '도구 규칙이 성공적으로 설치되었습니다',
   },
   en: {
     welcome: '\n🎉 Welcome to AIWF!\n',
@@ -138,7 +145,14 @@ export const messages = {
     checkingInstallation: 'Checking AIWF installation status...',
     creatingDirectories: 'Creating AIWF directory structure...',
     restoringBackup: 'Restoring files from backup...',
-    backupRestored: '{count} files restored'
+    backupRestored: '{count} files restored',
+    checkingExistingTools: 'Checking existing tool directories...',
+    foundExistingCursor: 'Found existing Cursor rules',
+    foundExistingWindsurf: 'Found existing Windsurf rules',
+    backingUpToolFiles: 'Backing up existing tool files...',
+    toolBackupCreated: 'Tool files backup created',
+    installingToolRules: 'Installing tool rules...',
+    toolRulesInstalled: 'Tool rules installed successfully',
   }
 };
 

package/src/utils/paths.js

@@ -56,11 +56,6 @@ export const FILES = {
   }
 };
 
-// Temporary directories
-export const TEMP_DIRS = {
-  RULES_GLOBAL: path.join(AIWF_DIRS.ROOT, '_tmp_rules_global'),
-  RULES_MANUAL: path.join(AIWF_DIRS.ROOT, '_tmp_rules_manual')
-};
 
 // User cache directory (for global cache)
 export const USER_CACHE_DIR = path.join(
@@ -103,18 +98,6 @@ export function getToolDirectory(tool) {
   return mapping[tool] || null;
 }
 
-// Get backup directory name with timestamp
-export function getBackupDirName() {
-  const now = new Date();
-  const pad = n => n.toString().padStart(2, '0');
-  const y = now.getFullYear();
-  const m = pad(now.getMonth() + 1);
-  const d = pad(now.getDate());
-  const h = pad(now.getHours());
-  const min = pad(now.getMinutes());
-  const s = pad(now.getSeconds());
-  return path.join(AIWF_DIRS.ROOT, `backup_${y}${m}${d}_${h}${min}${s}`);
-}
 
 // Export all for convenience
 export default {
@@ -122,10 +105,8 @@ export default {
   AIWF_DIRS,
   TOOL_DIRS,
   FILES,
-  TEMP_DIRS,
   USER_CACHE_DIR,
   getAllAiwfDirectories,
   getAllClaudeMdFiles,
-  getToolDirectory,
-  getBackupDirName
+  getToolDirectory
 };