aiwf 0.3.0 → 0.3.1

package/claude-code/aiwf/en/.claude/commands/aiwf/aiwf_language_manager.md

@@ -0,0 +1,287 @@
+# AIWF Language Manager
+
+A command that provides integrated management of language-related functions in the AIWF framework.
+
+## Usage
+
+```
+/project:aiwf:language_manager [action] [arguments]
+```
+
+### Action Types
+
+- `status` - Check current language status
+- `switch <language_code>` - Switch language  
+- `detect` - Auto-detect system language
+- `reset` - Reset language settings
+- `test` - Test language system
+- `config` - Manage configuration file
+
+## Execution Steps
+
+### 1. Argument Analysis and Action Routing
+
+```bash
+# Parse arguments
+ACTION="${1:-status}"
+ARGUMENT="${2:-}"
+
+echo "=== AIWF Language Manager ==="
+echo "Action: $ACTION"
+echo "Argument: $ARGUMENT"
+echo ""
+```
+
+### 2. Action-Specific Execution
+
+#### 2.1 Status Check (status)
+
+```bash
+if [ "$ACTION" = "status" ]; then
+  echo "📊 Checking language status..."
+  node -e "
+  import('./language-utils.js').then(async ({ getLanguageStatus }) => {
+    const status = await getLanguageStatus();
+    
+    console.log('=== Language Settings Status ===');
+    console.log('Detected language:', status.detectedLanguage);
+    console.log('Configured language:', status.configuredLanguage || 'None');
+    console.log('Effective language:', status.effectiveLanguage);
+    console.log('Auto detection:', status.autoDetect ? 'Enabled' : 'Disabled');
+    console.log('Fallback language:', status.fallbackLanguage);
+    console.log('Supported languages:', status.supportedLanguages.join(', '));
+    
+    if (status.error) {
+      console.log('⚠️ Error:', status.error);
+    }
+  });
+  "
+fi
+```
+
+#### 2.2 Language Switch (switch)
+
+```bash
+if [ "$ACTION" = "switch" ]; then
+  if [ -z "$ARGUMENT" ]; then
+    echo "❌ Error: Please specify a language code"
+    echo "Usage: /project:aiwf:language_manager switch [ko|en]"
+    exit 1
+  fi
+  
+  echo "🔄 Switching language to: $ARGUMENT"
+  node -e "
+  import('./language-utils.js').then(async ({ switchLanguage }) => {
+    const result = await switchLanguage(process.argv[1]);
+    
+    if (result.success) {
+      console.log('✅ Language switch successful!');
+      console.log('Previous language:', result.previousLanguage);
+      console.log('New language:', result.newLanguage);
+    } else {
+      console.error('❌ Language switch failed:', result.error);
+      process.exit(1);
+    }
+  });
+  " -- "$ARGUMENT"
+fi
+```
+
+#### 2.3 Language Detection (detect)
+
+```bash
+if [ "$ACTION" = "detect" ]; then
+  echo "🔍 Detecting system language..."
+  node -e "
+  import('./language-utils.js').then(async ({ detectLanguage }) => {
+    const detected = await detectLanguage();
+    
+    console.log('=== Language Detection Results ===');
+    console.log('Detected language:', detected);
+    console.log('');
+    console.log('Environment variables:');
+    console.log('  LANG:', process.env.LANG || 'Not set');
+    console.log('  LC_ALL:', process.env.LC_ALL || 'Not set');
+    console.log('  LANGUAGE:', process.env.LANGUAGE || 'Not set');
+  });
+  "
+fi
+```
+
+#### 2.4 Settings Reset (reset)
+
+```bash
+if [ "$ACTION" = "reset" ]; then
+  echo "🗑️ Resetting language settings..."
+  
+  # Delete configuration file
+  if [ -f ".aiwf/config/language.json" ]; then
+    rm ".aiwf/config/language.json"
+    echo "✅ Language configuration file has been deleted"
+  else
+    echo "ℹ️ Language configuration file does not exist"
+  fi
+  
+  # Perform re-detection
+  echo "🔄 Re-detecting language..."
+  node -e "
+  import('./language-utils.js').then(async ({ detectLanguage }) => {
+    const detected = await detectLanguage();
+    console.log('Re-detected language:', detected);
+  });
+  "
+fi
+```
+
+#### 2.5 System Test (test)
+
+```bash
+if [ "$ACTION" = "test" ]; then
+  echo "🧪 Testing language system..."
+  node -e "
+  import('./language-utils.js').then(async (utils) => {
+    const { resolveCommandPath, detectLanguage, getLocalizedMessage } = utils;
+    
+    console.log('=== Language System Test ===');
+    
+    // 1. Language detection test
+    const detected = await detectLanguage();
+    console.log('✅ Language detection:', detected);
+    
+    // 2. Command path resolution test
+    const testCommands = ['aiwf_do_task', 'aiwf_commit'];
+    console.log('\n📁 Command path test:');
+    
+    for (const cmd of testCommands) {
+      const result = await resolveCommandPath(cmd);
+      if (result.path) {
+        console.log('  ✅', cmd, result.fallback ? '(fallback)' : '(direct)');
+      } else {
+        console.log('  ❌', cmd, 'failed');
+      }
+    }
+    
+    // 3. Message system test
+    console.log('\n💬 Message system test:');
+    const testMsg = getLocalizedMessage('LANGUAGE_NOT_SUPPORTED', detected);
+    console.log('  Message:', testMsg);
+    
+    console.log('\n✅ All tests completed');
+  });
+  "
+fi
+```
+
+#### 2.6 Configuration Management (config)
+
+```bash
+if [ "$ACTION" = "config" ]; then
+  echo "⚙️ Language configuration file management"
+  
+  CONFIG_FILE=".aiwf/config/language.json"
+  
+  if [ -f "$CONFIG_FILE" ]; then
+    echo "📄 Current configuration file contents:"
+    cat "$CONFIG_FILE" | jq . 2>/dev/null || cat "$CONFIG_FILE"
+    echo ""
+    
+    echo "📊 Configuration file info:"
+    echo "  Location: $CONFIG_FILE"
+    echo "  Size: $(stat -f%z "$CONFIG_FILE" 2>/dev/null || stat -c%s "$CONFIG_FILE" 2>/dev/null) bytes"
+    echo "  Modified: $(stat -f%Sm "$CONFIG_FILE" 2>/dev/null || stat -c%y "$CONFIG_FILE" 2>/dev/null)"
+  else
+    echo "❌ Configuration file does not exist: $CONFIG_FILE"
+    echo ""
+    echo "💡 To create a configuration file, set a language:"
+    echo "   /project:aiwf:language_manager switch ko"
+    echo "   /project:aiwf:language_manager switch en"
+  fi
+fi
+```
+
+### 3. Help (default)
+
+```bash
+if [ "$ACTION" = "help" ] || [ "$ACTION" = "--help" ]; then
+  echo "📖 AIWF Language Manager Help"
+  echo ""
+  echo "Usage:"
+  echo "  /project:aiwf:language_manager [action] [arguments]"
+  echo ""
+  echo "Actions:"
+  echo "  status          Check current language status"
+  echo "  switch <lang>   Switch language (ko|en)"
+  echo "  detect          Auto-detect system language"
+  echo "  reset           Reset language settings"
+  echo "  test            Test language system"
+  echo "  config          Manage configuration file"
+  echo "  help            Show this help"
+  echo ""
+  echo "Examples:"
+  echo "  /project:aiwf:language_manager status"
+  echo "  /project:aiwf:language_manager switch ko"
+  echo "  /project:aiwf:language_manager test"
+fi
+```
+
+### 4. Result Summary
+
+```bash
+echo ""
+echo "=== Execution Complete ==="
+echo "Action: $ACTION"
+echo "Time: $(date '+%Y-%m-%d %H:%M:%S')"
+
+# Simple current language status display
+node -e "
+import('./language-utils.js').then(async ({ detectLanguage }) => {
+  const lang = await detectLanguage();
+  console.log('Current language:', lang);
+});
+" 2>/dev/null || echo "Current language: Unable to detect"
+```
+
+## Output Examples
+
+### Status Check
+```
+=== AIWF Language Manager ===
+Action: status
+
+📊 Checking language status...
+=== Language Settings Status ===
+Detected language: en
+Configured language: en  
+Effective language: en
+Auto detection: Enabled
+Fallback language: en
+Supported languages: ko, en
+
+=== Execution Complete ===
+Action: status
+Time: 2025-07-03 06:25:30
+Current language: en
+```
+
+### Language Switch
+```
+=== AIWF Language Manager ===
+Action: switch
+Argument: ko
+
+🔄 Switching language to: ko
+✅ Language switch successful!
+Previous language: en
+New language: ko
+
+=== Execution Complete ===
+Action: switch
+Time: 2025-07-03 06:25:35
+Current language: ko
+```
+
+## Related Commands
+
+- `/project:aiwf:switch_language` - Simple language switching
+- `/project:aiwf:language_status` - Detailed status check
+- `/project:aiwf:initialize` - AIWF initialization (includes language selection)

package/claude-code/aiwf/en/.claude/commands/aiwf/aiwf_language_status.md

@@ -0,0 +1,246 @@
+# AIWF Language Status Check
+
+A command to check the detailed language configuration status of the AIWF framework.
+
+## Usage
+
+This command provides the following information:
+- Currently detected system language
+- User-configured language (if any)
+- Actually used language
+- Language configuration file status
+- Command path resolution status
+
+## Execution Process
+
+### 1. Comprehensive Language Status Analysis
+
+```bash
+node -e "
+import('./language-utils.js').then(async (utils) => {
+  const { getLanguageStatus, resolveCommandPath, getLocalizedMessage } = utils;
+  
+  console.log('=== AIWF Language System Status Analysis ===\n');
+  
+  // Basic status information
+  const status = await getLanguageStatus();
+  
+  console.log('📍 Basic Information:');
+  console.log('  Detected language:', status.detectedLanguage);
+  console.log('  Configured language:', status.configuredLanguage || 'None');
+  console.log('  Effective language:', status.effectiveLanguage);
+  console.log('  Auto detection:', status.autoDetect ? 'Enabled' : 'Disabled');
+  console.log('  Fallback language:', status.fallbackLanguage);
+  console.log('  Supported languages:', status.supportedLanguages.join(', '));
+  console.log('  Config file:', status.configPath);
+  
+  if (status.error) {
+    console.log('  ⚠️ Error:', status.error);
+  }
+  
+  console.log('\n📂 Config File Status:');
+  try {
+    const fs = await import('fs/promises');
+    const configExists = await fs.access(status.configPath).then(() => true).catch(() => false);
+    
+    if (configExists) {
+      const configContent = await fs.readFile(status.configPath, 'utf8');
+      const config = JSON.parse(configContent);
+      console.log('  ✅ Config file exists');
+      console.log('  📄 Contents:', JSON.stringify(config, null, 4));
+    } else {
+      console.log('  ❌ Config file not found');
+    }
+  } catch (error) {
+    console.log('  ⚠️ Config file read error:', error.message);
+  }
+});
+"
+```
+
+### 2. Environment Variables Analysis
+
+```bash
+node -e "
+console.log('\n🌍 System Environment Variables:');
+console.log('  LANG:', process.env.LANG || 'Not set');
+console.log('  LC_ALL:', process.env.LC_ALL || 'Not set');
+console.log('  LANGUAGE:', process.env.LANGUAGE || 'Not set');
+console.log('  NODE_ENV:', process.env.NODE_ENV || 'Not set');
+"
+```
+
+### 3. Command Path Testing
+
+```bash
+node -e "
+import('./language-utils.js').then(async ({ resolveCommandPath, detectLanguage }) => {
+  console.log('\n🔍 Command Path Resolution Testing:');
+  
+  const currentLang = await detectLanguage();
+  console.log('  Current language:', currentLang);
+  
+  const testCommands = [
+    'aiwf_do_task',
+    'aiwf_commit', 
+    'aiwf_initialize',
+    'aiwf_switch_language',
+    'aiwf_test',
+    'aiwf_code_review',
+    'aiwf_project_review'
+  ];
+  
+  for (const cmd of testCommands) {
+    const result = await resolveCommandPath(cmd);
+    if (result.path) {
+      const status = result.fallback ? '🔄 Fallback' : '✅ Direct';
+      console.log('  ' + status, cmd + ':', result.language);
+    } else {
+      console.log('  ❌ Missing', cmd + ':', result.error);
+    }
+  }
+});
+"
+```
+
+### 4. Message System Testing
+
+```bash
+node -e "
+import('./language-utils.js').then(async ({ getLocalizedMessage, detectLanguage }) => {
+  console.log('\n💬 Multilingual Message System Testing:');
+  
+  const currentLang = await detectLanguage();
+  console.log('  Current language:', currentLang);
+  
+  const testMessages = [
+    'LANGUAGE_NOT_SUPPORTED',
+    'CONFIG_LOAD_FAILED', 
+    'CONFIG_SAVE_FAILED',
+    'COMMAND_NOT_FOUND',
+    'LANGUAGE_SWITCH_SUCCESS'
+  ];
+  
+  for (const msgKey of testMessages) {
+    const koMsg = getLocalizedMessage(msgKey, 'ko');
+    const enMsg = getLocalizedMessage(msgKey, 'en');
+    console.log('  ' + msgKey + ':');
+    console.log('    Korean: ' + koMsg);
+    console.log('    English: ' + enMsg);
+  }
+});
+"
+```
+
+### 5. Directory Structure Check
+
+```bash
+node -e "
+const fs = await import('fs/promises');
+const path = await import('path');
+
+console.log('\n📁 AIWF Directory Structure:');
+
+const checkDirs = [
+  '.aiwf',
+  '.aiwf/config',
+  '.claude',
+  '.claude/commands',
+  '.claude/commands/aiwf',
+  'claude-code/aiwf/ko/.claude/commands/aiwf',
+  'claude-code/aiwf/en/.claude/commands/aiwf'
+];
+
+for (const dir of checkDirs) {
+  try {
+    const exists = await fs.access(dir).then(() => true).catch(() => false);
+    if (exists) {
+      const files = await fs.readdir(dir);
+      console.log('  ✅', dir + ':', files.length + ' files');
+    } else {
+      console.log('  ❌', dir + ':', 'Directory not found');
+    }
+  } catch (error) {
+    console.log('  ⚠️', dir + ':', 'Access error');
+  }
+}
+"
+```
+
+## Diagnostics and Recommendations
+
+### Language Detection Problem Resolution
+
+The command provides the following recommendations:
+
+1. **When config file is missing**:
+   ```
+   💡 Recommendation: Explicitly set the language
+   /project:aiwf:switch_language ko
+   ```
+
+2. **Environment variable issues**:
+   ```
+   💡 Recommendation: Check environment variables
+   export LANG=en_US.UTF-8
+   ```
+
+3. **Missing command files**:
+   ```
+   💡 Recommendation: Reinstall AIWF
+   npx aiwf --force
+   ```
+
+## Output Example
+
+```
+=== AIWF Language System Status Analysis ===
+
+📍 Basic Information:
+  Detected language: en
+  Configured language: en
+  Effective language: en
+  Auto detection: Enabled
+  Fallback language: en
+  Supported languages: ko, en
+  Config file: .aiwf/config/language.json
+
+📂 Config File Status:
+  ✅ Config file exists
+  📄 Contents: {
+      "language": "en",
+      "auto_detect": true,
+      "last_updated": "2025-07-03T06:25:00.000Z",
+      "fallback": "en"
+  }
+
+🌍 System Environment Variables:
+  LANG: en_US.UTF-8
+  LC_ALL: Not set
+  LANGUAGE: Not set
+  NODE_ENV: Not set
+
+🔍 Command Path Resolution Testing:
+  Current language: en
+  ✅ Direct aiwf_do_task: en
+  ✅ Direct aiwf_commit: en
+  ✅ Direct aiwf_initialize: en
+  ✅ Direct aiwf_switch_language: en
+  🔄 Fallback aiwf_test: ko
+  ❌ Missing aiwf_unknown: Command file not found
+
+💬 Multilingual Message System Testing:
+  Current language: en
+  LANGUAGE_NOT_SUPPORTED:
+    Korean: 지원되지 않는 언어입니다
+    English: Language not supported
+  
+📁 AIWF Directory Structure:
+  ✅ .aiwf: 8 files
+  ✅ .aiwf/config: 1 file
+  ✅ .claude: 2 files
+  ✅ .claude/commands: 1 file
+  ❌ .claude/commands/aiwf: Directory not found
+  ✅ claude-code/aiwf/ko/.claude/commands/aiwf: 15 files
+  ✅ claude-code/aiwf/en/.claude/commands/aiwf: 14 files
+```

package/claude-code/aiwf/en/.claude/commands/aiwf/aiwf_switch_language.md

@@ -0,0 +1,160 @@
+# AIWF Language Switch
+
+A command that allows users to change the language settings of the AIWF framework.
+
+## Usage
+
+This command is used in the following cases:
+- When you want to change the current language setting to another language
+- When you want to check the current language setting status
+- When you want to resolve language detection issues
+
+## Parameters
+
+- `<language_code>` (optional): Language to switch to (`ko` or `en`)
+- Running without parameters displays the current language status
+
+## Execution Steps
+
+### 1. Check Current Language Status
+
+First, check the current language configuration status:
+
+```bash
+node -e "
+import('./language-utils.js').then(async ({ getLanguageStatus }) => {
+  const status = await getLanguageStatus();
+  console.log('=== AIWF Language Settings Status ===');
+  console.log('Detected language:', status.detectedLanguage);
+  console.log('Configured language:', status.configuredLanguage || 'None');
+  console.log('Effective language:', status.effectiveLanguage);
+  console.log('Auto detection:', status.autoDetect ? 'Enabled' : 'Disabled');
+  console.log('Fallback language:', status.fallbackLanguage);
+  console.log('Config file path:', status.configPath);
+  if (status.error) console.log('Error:', status.error);
+});
+"
+```
+
+### 2. Argument Analysis
+
+Check the `<$ARGUMENTS>` value and perform one of the following:
+
+- **No arguments**: Display current status only and exit
+- **Valid language code (`ko` or `en`)**: Switch to that language
+- **Invalid argument**: Display error message and usage guide
+
+### 3. Execute Language Switch
+
+If a valid language code is provided, switch the language:
+
+```bash
+node -e "
+import('./language-utils.js').then(async ({ switchLanguage }) => {
+  const targetLanguage = process.argv[1];
+  const result = await switchLanguage(targetLanguage);
+  
+  if (result.success) {
+    console.log('✅ Language switch successful!');
+    console.log('Previous language:', result.previousLanguage);
+    console.log('New language:', result.newLanguage);
+    console.log('Message:', result.message);
+  } else {
+    console.error('❌ Language switch failed:', result.error);
+    console.log('Message:', result.message);
+  }
+});
+" -- $ARGUMENTS
+```
+
+### 4. Post-Switch Validation
+
+Verify that the settings are properly applied after the language switch:
+
+```bash
+node -e "
+import('./language-utils.js').then(async ({ getLanguageStatus }) => {
+  const status = await getLanguageStatus();
+  console.log('\n=== Post-Switch Language Settings Status ===');
+  console.log('Current language:', status.effectiveLanguage);
+  console.log('Config file:', status.configuredLanguage ? 'Saved' : 'None');
+});
+"
+```
+
+### 5. Command Path Testing
+
+Test if command paths are properly resolved with the new language:
+
+```bash
+node -e "
+import('./language-utils.js').then(async ({ resolveCommandPath, detectLanguage }) => {
+  const currentLang = await detectLanguage();
+  const testCommands = ['aiwf_do_task', 'aiwf_commit', 'aiwf_initialize'];
+  
+  console.log('\n=== Command Path Testing ===');
+  console.log('Current language:', currentLang);
+  
+  for (const cmd of testCommands) {
+    const result = await resolveCommandPath(cmd);
+    if (result.path) {
+      console.log('✅', cmd, '->', result.path, result.fallback ? '(fallback)' : '(direct)');
+    } else {
+      console.log('❌', cmd, '-> Not found:', result.error);
+    }
+  }
+});
+"
+```
+
+## Output Format
+
+### Successful Language Switch
+```
+✅ Language switch successful!
+Previous language: en
+New language: ko
+Message: Language changed successfully
+
+=== Post-Switch Language Settings Status ===
+Current language: ko
+Config file: Saved
+
+=== Command Path Testing ===
+Current language: ko
+✅ aiwf_do_task -> claude-code/aiwf/ko/.claude/commands/aiwf/aiwf_do_task.md (direct)
+✅ aiwf_commit -> claude-code/aiwf/ko/.claude/commands/aiwf/aiwf_commit.md (direct)
+✅ aiwf_initialize -> claude-code/aiwf/ko/.claude/commands/aiwf/aiwf_initialize.md (direct)
+```
+
+### Status Check Only
+```
+=== AIWF Language Settings Status ===
+Detected language: ko
+Configured language: ko
+Effective language: ko
+Auto detection: Enabled
+Fallback language: en
+Config file path: .aiwf/config/language.json
+```
+
+### Error Occurred
+```
+❌ Language switch failed: Language not supported
+Message: Failed to change language
+
+Usage: /project:aiwf:switch_language [ko|en]
+Supported languages: ko (Korean), en (English)
+```
+
+## Important Notes
+
+1. **Config File Permissions**: Write permissions are required for the `.aiwf/config/` directory
+2. **Command File Existence**: Command files for the target language must exist
+3. **Project Root**: Can only be used in projects where AIWF has been initialized
+
+## Related Commands
+
+- `/project:aiwf:initialize` - Initialize AIWF project
+- `/project:aiwf:update_docs` - Update documentation (language-specific)
+- `/project:aiwf:help` - Help (displayed in current language)