aiwf 0.3.6 → 0.3.8

package/src/commands/token.js

@@ -0,0 +1,312 @@
+#!/usr/bin/env node
+
+/**
+ * AIWF 토큰 추적 명령어
+ * AI 토큰 사용량 모니터링 및 분석
+ */
+
+import { ResourceLoader } from '../lib/resource-loader.js';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+
+class TokenCommand {
+  constructor() {
+    this.resourceLoader = new ResourceLoader();
+    this.tokenDataPath = path.join(process.cwd(), '.aiwf', 'token-usage');
+  }
+
+  /**
+   * Token 명령어 실행
+   */
+  async execute(args) {
+    const [subcommand, ...restArgs] = args;
+
+    switch (subcommand) {
+      case 'status':
+        await this.showStatus();
+        break;
+      case 'report':
+        await this.generateReport(restArgs);
+        break;
+      case 'track':
+        await this.trackUsage(restArgs);
+        break;
+      case 'reset':
+        await this.resetTracking();
+        break;
+      case 'limit':
+        await this.setLimit(restArgs);
+        break;
+      default:
+        this.showHelp();
+        break;
+    }
+  }
+
+  /**
+   * 토큰 사용 상태 표시
+   */
+  async showStatus() {
+    try {
+      // 토큰 추적 모듈 로드
+      const tokenTrackerModule = await this.resourceLoader.loadUtil('token-tracker.js');
+      const TokenTracker = tokenTrackerModule.TokenTracker || tokenTrackerModule.default;
+      
+      if (!TokenTracker) {
+        throw new Error('TokenTracker 모듈을 로드할 수 없습니다.');
+      }
+
+      const tracker = new TokenTracker({
+        storageDir: this.tokenDataPath
+      });
+
+      await tracker.init();
+      const stats = await tracker.getStatistics();
+      const limits = await this.getLimits();
+
+      console.log(chalk.cyan('💰 토큰 사용 현황'));
+      console.log(chalk.gray('-'.repeat(50)));
+      
+      // 오늘 사용량
+      console.log(chalk.bold('오늘 사용량:'));
+      console.log(`  입력 토큰: ${chalk.yellow(stats.today.input.toLocaleString())}`);
+      console.log(`  출력 토큰: ${chalk.yellow(stats.today.output.toLocaleString())}`);
+      console.log(`  총 토큰: ${chalk.yellow(stats.today.total.toLocaleString())}`);
+      
+      if (limits.daily > 0) {
+        const dailyUsagePercent = (stats.today.total / limits.daily * 100).toFixed(1);
+        const dailyColor = dailyUsagePercent > 90 ? 'red' : dailyUsagePercent > 70 ? 'yellow' : 'green';
+        console.log(`  일일 한도: ${chalk[dailyColor](`${dailyUsagePercent}% 사용`)}`);
+      }
+
+      // 이번 주 사용량
+      console.log(chalk.bold('\n이번 주 사용량:'));
+      console.log(`  입력 토큰: ${chalk.yellow(stats.week.input.toLocaleString())}`);
+      console.log(`  출력 토큰: ${chalk.yellow(stats.week.output.toLocaleString())}`);
+      console.log(`  총 토큰: ${chalk.yellow(stats.week.total.toLocaleString())}`);
+
+      // 이번 달 사용량
+      console.log(chalk.bold('\n이번 달 사용량:'));
+      console.log(`  입력 토큰: ${chalk.yellow(stats.month.input.toLocaleString())}`);
+      console.log(`  출력 토큰: ${chalk.yellow(stats.month.output.toLocaleString())}`);
+      console.log(`  총 토큰: ${chalk.yellow(stats.month.total.toLocaleString())}`);
+      
+      if (limits.monthly > 0) {
+        const monthlyUsagePercent = (stats.month.total / limits.monthly * 100).toFixed(1);
+        const monthlyColor = monthlyUsagePercent > 90 ? 'red' : monthlyUsagePercent > 70 ? 'yellow' : 'green';
+        console.log(`  월간 한도: ${chalk[monthlyColor](`${monthlyUsagePercent}% 사용`)}`);
+      }
+
+      // 전체 통계
+      console.log(chalk.bold('\n전체 통계:'));
+      console.log(`  총 세션: ${stats.overall.sessions}`);
+      console.log(`  평균 세션당 토큰: ${Math.round(stats.overall.total / stats.overall.sessions).toLocaleString()}`);
+      console.log(`  최대 단일 세션: ${stats.overall.maxSession.toLocaleString()} 토큰`);
+
+      console.log(chalk.gray('\n' + '-'.repeat(50)));
+      console.log(chalk.gray('상세 리포트: aiwf token report'));
+      
+    } catch (error) {
+      console.error(chalk.red('❌ 토큰 상태 조회 중 오류가 발생했습니다:'), error.message);
+    }
+  }
+
+  /**
+   * 토큰 사용 리포트 생성
+   */
+  async generateReport(args) {
+    const [period = 'week'] = args;
+    
+    try {
+      // 토큰 리포터 모듈 로드
+      const reporterModule = await this.resourceLoader.loadUtil('token-reporter.js');
+      const TokenReporter = reporterModule.TokenReporter || reporterModule.default;
+      
+      if (!TokenReporter) {
+        throw new Error('TokenReporter 모듈을 로드할 수 없습니다.');
+      }
+
+      const reporter = new TokenReporter({
+        storageDir: this.tokenDataPath
+      });
+
+      console.log(chalk.cyan(`📊 토큰 사용 리포트 (${period})`));
+      console.log(chalk.gray('생성 중...'));
+
+      const report = await reporter.generateReport(period);
+      const reportPath = path.join(this.tokenDataPath, 'reports', `token-report-${period}-${Date.now()}.md`);
+      
+      await fs.ensureDir(path.dirname(reportPath));
+      await fs.writeFile(reportPath, report);
+
+      console.log(chalk.green(`✅ 리포트가 생성되었습니다: ${reportPath}`));
+      
+      // 리포트 요약 표시
+      console.log(chalk.cyan('\n📄 리포트 요약:'));
+      const lines = report.split('\n').slice(0, 20);
+      console.log(lines.join('\n'));
+      console.log(chalk.gray('\n... (전체 리포트는 파일을 확인하세요)'));
+      
+    } catch (error) {
+      console.error(chalk.red('❌ 리포트 생성 중 오류가 발생했습니다:'), error.message);
+    }
+  }
+
+  /**
+   * 토큰 사용량 추적
+   */
+  async trackUsage(args) {
+    const [inputTokens, outputTokens] = args.map(Number);
+    
+    if (!inputTokens || !outputTokens) {
+      console.error(chalk.red('❌ 입력 토큰과 출력 토큰 수를 지정해주세요.'));
+      console.log(chalk.gray('사용법: aiwf token track <입력토큰> <출력토큰>'));
+      return;
+    }
+
+    try {
+      const trackerModule = await this.resourceLoader.loadUtil('token-tracker.js');
+      const TokenTracker = trackerModule.TokenTracker || trackerModule.default;
+      
+      const tracker = new TokenTracker({
+        storageDir: this.tokenDataPath
+      });
+
+      await tracker.init();
+      await tracker.trackUsage({
+        input: inputTokens,
+        output: outputTokens,
+        timestamp: new Date().toISOString(),
+        source: 'manual'
+      });
+
+      console.log(chalk.green('✅ 토큰 사용량이 기록되었습니다.'));
+      console.log(`입력: ${chalk.yellow(inputTokens.toLocaleString())} 토큰`);
+      console.log(`출력: ${chalk.yellow(outputTokens.toLocaleString())} 토큰`);
+      console.log(`총합: ${chalk.yellow((inputTokens + outputTokens).toLocaleString())} 토큰`);
+      
+    } catch (error) {
+      console.error(chalk.red('❌ 토큰 추적 중 오류가 발생했습니다:'), error.message);
+    }
+  }
+
+  /**
+   * 토큰 추적 초기화
+   */
+  async resetTracking() {
+    try {
+      const confirm = await this.confirmReset();
+      if (!confirm) {
+        console.log(chalk.yellow('초기화가 취소되었습니다.'));
+        return;
+      }
+
+      await fs.remove(this.tokenDataPath);
+      console.log(chalk.green('✅ 토큰 추적 데이터가 초기화되었습니다.'));
+      
+    } catch (error) {
+      console.error(chalk.red('❌ 초기화 중 오류가 발생했습니다:'), error.message);
+    }
+  }
+
+  /**
+   * 토큰 사용 한도 설정
+   */
+  async setLimit(args) {
+    const [limitType, limitValue] = args;
+    
+    if (!limitType || !limitValue) {
+      console.error(chalk.red('❌ 한도 유형과 값을 지정해주세요.'));
+      console.log(chalk.gray('사용법: aiwf token limit <daily|monthly> <값>'));
+      return;
+    }
+
+    const validTypes = ['daily', 'monthly'];
+    if (!validTypes.includes(limitType)) {
+      console.error(chalk.red(`❌ 유효하지 않은 한도 유형: ${limitType}`));
+      console.log(chalk.gray('유효한 유형: daily, monthly'));
+      return;
+    }
+
+    const limit = parseInt(limitValue);
+    if (isNaN(limit) || limit < 0) {
+      console.error(chalk.red('❌ 한도 값은 0 이상의 숫자여야 합니다.'));
+      return;
+    }
+
+    try {
+      const configPath = path.join(this.tokenDataPath, 'limits.json');
+      await fs.ensureDir(this.tokenDataPath);
+      
+      let limits = {};
+      if (fs.existsSync(configPath)) {
+        limits = await fs.readJson(configPath);
+      }
+
+      limits[limitType] = limit;
+      await fs.writeJson(configPath, limits, { spaces: 2 });
+
+      console.log(chalk.green(`✅ ${limitType === 'daily' ? '일일' : '월간'} 한도가 ${limit.toLocaleString()} 토큰으로 설정되었습니다.`));
+      
+    } catch (error) {
+      console.error(chalk.red('❌ 한도 설정 중 오류가 발생했습니다:'), error.message);
+    }
+  }
+
+  /**
+   * 한도 설정 가져오기
+   */
+  async getLimits() {
+    try {
+      const configPath = path.join(this.tokenDataPath, 'limits.json');
+      if (fs.existsSync(configPath)) {
+        return await fs.readJson(configPath);
+      }
+    } catch (error) {
+      // 에러 무시
+    }
+    return { daily: 0, monthly: 0 };
+  }
+
+  /**
+   * 초기화 확인
+   */
+  async confirmReset() {
+    // 간단한 확인 (실제로는 prompts 패키지 사용 권장)
+    console.log(chalk.yellow('⚠️  모든 토큰 추적 데이터가 삭제됩니다.'));
+    console.log(chalk.gray('계속하려면 5초 내에 Ctrl+C로 취소하세요...'));
+    
+    await new Promise(resolve => setTimeout(resolve, 5000));
+    return true;
+  }
+
+  /**
+   * 도움말 표시
+   */
+  showHelp() {
+    console.log(chalk.cyan('💰 AIWF 토큰 추적'));
+    console.log(chalk.gray('-'.repeat(50)));
+    console.log('사용법: aiwf token <명령어> [옵션]');
+    console.log('');
+    console.log('명령어:');
+    console.log('  status                  토큰 사용 현황 표시');
+    console.log('  report [기간]           사용 리포트 생성');
+    console.log('  track <입력> <출력>     토큰 사용량 수동 기록');
+    console.log('  limit <유형> <값>       사용 한도 설정');
+    console.log('  reset                   추적 데이터 초기화');
+    console.log('');
+    console.log('리포트 기간:');
+    console.log('  day     일간 리포트');
+    console.log('  week    주간 리포트 (기본값)');
+    console.log('  month   월간 리포트');
+    console.log('');
+    console.log('예시:');
+    console.log('  aiwf token status');
+    console.log('  aiwf token report week');
+    console.log('  aiwf token track 1500 500');
+    console.log('  aiwf token limit daily 100000');
+  }
+}
+
+export default TokenCommand;

package/src/lib/file-downloader.js

@@ -6,6 +6,10 @@ import path from 'path';
 
 const GITHUB_RAW_URL = 'https://raw.githubusercontent.com/moonklabs/aiwf/main';
 const GITHUB_CONTENT_PREFIX = 'claude-code/aiwf';
+const GITHUB_API_URL = 'https://api.github.com/repos/moonklabs/aiwf/contents';
+const GITHUB_OWNER = 'moonklabs';
+const GITHUB_REPO = 'aiwf';
+const GITHUB_BRANCH = 'main';
 
 // Pre-defined list of command files
 const COMMAND_FILES = [
@@ -82,16 +86,22 @@ const PROMPT_FILES = [
 /**
  * Fetch content from URL
  * @param {string} url - The URL to fetch from
+ * @param {Object} headers - Optional headers
  * @returns {Promise<string>} The response content
  */
-async function fetchContent(url) {
+async function fetchContent(url, headers = {}) {
   return new Promise((resolve, reject) => {
-    https.get(url, { headers: { 'User-Agent': 'aiwf' } }, (res) => {
+    const defaultHeaders = { 'User-Agent': 'aiwf' };
+    const requestHeaders = { ...defaultHeaders, ...headers };
+    
+    https.get(url, { headers: requestHeaders }, (res) => {
       let data = '';
       res.on('data', chunk => data += chunk);
       res.on('end', () => {
         if (res.statusCode === 200) {
           resolve(data);
+        } else if (res.statusCode === 403 && res.headers['x-ratelimit-remaining'] === '0') {
+          reject(new Error('GitHub API rate limit exceeded. Please try again later.'));
         } else {
           reject(new Error(`Failed to fetch ${url}: ${res.statusCode}`));
         }
@@ -104,35 +114,164 @@ async function fetchContent(url) {
 }
 
 /**
- * Download a file from URL to destination path
+ * Sleep for specified milliseconds
+ * @param {number} ms - Milliseconds to sleep
+ * @returns {Promise<void>}
+ */
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Fetch directory contents from GitHub API with retry logic
+ * @param {string} path - Repository path
+ * @param {number} retries - Number of retries for rate limit
+ * @returns {Promise<Array>} Array of file/directory objects
+ */
+async function fetchGitHubDirectory(path, retries = 3) {
+  const apiUrl = `${GITHUB_API_URL}/${path}?ref=${GITHUB_BRANCH}`;
+  
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      const response = await fetchContent(apiUrl, {
+        'Accept': 'application/vnd.github.v3+json'
+      });
+      return JSON.parse(response);
+    } catch (error) {
+      if (error.message.includes('rate limit exceeded') && attempt < retries) {
+        console.warn(`GitHub API rate limit hit. Retrying in ${(attempt + 1) * 10} seconds...`);
+        await sleep((attempt + 1) * 10000); // 10s, 20s, 30s
+        continue;
+      }
+      
+      // GitHub API가 실패하면 빈 배열 반환
+      console.warn(`Failed to fetch directory listing for ${path}: ${error.message}`);
+      
+      // 404 에러의 경우 정상적으로 빈 배열 반환 (디렉토리가 없는 경우)
+      if (error.message.includes('404')) {
+        return [];
+      }
+      
+      // Rate limit이나 다른 에러의 경우 재시도 후 실패
+      if (attempt === retries) {
+        throw error;
+      }
+    }
+  }
+  
+  return [];
+}
+
+/**
+ * Recursively download directory contents
+ * @param {string} githubPath - GitHub repository path
+ * @param {string} localPath - Local destination path
+ * @param {Object} spinner - Ora spinner instance
+ * @param {boolean} debugLog - Debug logging flag
+ * @returns {Promise<void>}
+ */
+async function downloadDirectoryRecursive(githubPath, localPath, spinner, debugLog = false) {
+  try {
+    // GitHub API로 디렉토리 내용 가져오기
+    const contents = await fetchGitHubDirectory(githubPath);
+    
+    if (contents.length === 0) {
+      if (debugLog) console.log(`No contents found in ${githubPath}`);
+      return;
+    }
+    
+    // 로컬 디렉토리 생성
+    await fs.mkdir(localPath, { recursive: true });
+    
+    for (const item of contents) {
+      if (item.type === 'file') {
+        // 파일 다운로드
+        const destPath = path.join(localPath, item.name);
+        const downloadUrl = item.download_url;
+        
+        try {
+          await downloadFile(downloadUrl, destPath);
+          if (spinner) {
+            spinner.text = `Downloaded: ${item.name}`;
+          }
+          if (debugLog) console.log(`Downloaded: ${githubPath}/${item.name}`);
+        } catch (error) {
+          if (debugLog) console.error(`Failed to download ${item.name}: ${error.message}`);
+        }
+      } else if (item.type === 'dir') {
+        // 하위 디렉토리 재귀적으로 처리
+        const subGithubPath = `${githubPath}/${item.name}`;
+        const subLocalPath = path.join(localPath, item.name);
+        
+        if (spinner) {
+          spinner.text = `Processing directory: ${item.name}`;
+        }
+        
+        await downloadDirectoryRecursive(subGithubPath, subLocalPath, spinner, debugLog);
+      }
+    }
+  } catch (error) {
+    if (debugLog) console.error(`Error processing directory ${githubPath}: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * Download a file from URL to destination path with retry logic
  * @param {string} url - The URL to download from
  * @param {string} destPath - The destination file path
+ * @param {number} retries - Number of retries
  * @returns {Promise<void>}
  */
-async function downloadFile(url, destPath) {
+async function downloadFile(url, destPath, retries = 3) {
   // Ensure destination directory exists
   const destDir = path.dirname(destPath);
   await fs.mkdir(destDir, { recursive: true });
   
-  return new Promise((resolve, reject) => {
-    https.get(url, { headers: { 'User-Agent': 'aiwf' } }, (response) => {
-      if (response.statusCode !== 200) {
-        response.destroy();
-        reject(new Error(`Failed to download ${url}: ${response.statusCode}`));
-        return;
-      }
-      const file = createWriteStream(destPath);
-      pipeline(response, file)
-        .then(() => {
-          resolve();
-        })
-        .catch((error) => {
-          reject(error);
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      await new Promise((resolve, reject) => {
+        https.get(url, { headers: { 'User-Agent': 'aiwf' } }, (response) => {
+          if (response.statusCode === 403 && response.headers['x-ratelimit-remaining'] === '0') {
+            response.destroy();
+            reject(new Error('GitHub API rate limit exceeded'));
+            return;
+          }
+          
+          if (response.statusCode !== 200) {
+            response.destroy();
+            reject(new Error(`Failed to download ${url}: ${response.statusCode}`));
+            return;
+          }
+          
+          const file = createWriteStream(destPath);
+          pipeline(response, file)
+            .then(() => {
+              resolve();
+            })
+            .catch((error) => {
+              reject(error);
+            });
+        }).on('error', (err) => {
+          reject(err);
         });
-    }).on('error', (err) => {
-      reject(err);
-    });
-  });
+      });
+      
+      // 성공하면 반환
+      return;
+    } catch (error) {
+      if (error.message.includes('rate limit exceeded') && attempt < retries) {
+        console.warn(`Rate limit hit while downloading ${path.basename(destPath)}. Retrying in ${(attempt + 1) * 10} seconds...`);
+        await sleep((attempt + 1) * 10000);
+        continue;
+      }
+      
+      // 마지막 시도에서도 실패하면 에러 throw
+      if (attempt === retries) {
+        throw error;
+      }
+    }
+  }
 }
 
 /**
@@ -164,17 +303,33 @@ async function downloadFileList(githubPath, localPath, fileList, spinner, messag
 }
 
 /**
- * Download directory contents using predefined file lists
+ * Download directory contents using predefined file lists or dynamic fetching
  * @param {string} githubPath - GitHub repository path
  * @param {string} localPath - Local destination path
  * @param {Object} spinner - Ora spinner instance
  * @param {Object} messages - Localized messages
  * @param {string} [selectedLanguage='en'] - Selected language
+ * @param {boolean} [useDynamicFetch=false] - Use GitHub API for dynamic fetching
  * @returns {Promise<void>}
  */
-async function downloadDirectory(githubPath, localPath, spinner, messages, selectedLanguage = 'en') {
+async function downloadDirectory(githubPath, localPath, spinner, messages, selectedLanguage = 'en', useDynamicFetch = false) {
   try {
-    // Determine which file list to use based on the path
+    // .aiwf 디렉토리나 알 수 없는 디렉토리의 경우 동적 다운로드 사용
+    if (useDynamicFetch || githubPath.includes('.aiwf') || 
+        (!githubPath.includes('.claude/commands/aiwf') && 
+         !githubPath.includes('rules/global') && 
+         !githubPath.includes('rules/manual'))) {
+      
+      if (spinner) {
+        spinner.text = `Fetching directory structure: ${githubPath}`;
+      }
+      
+      // GitHub API를 사용한 동적 디렉토리 다운로드
+      await downloadDirectoryRecursive(githubPath, localPath, spinner, messages && messages.debugLog);
+      return;
+    }
+    
+    // 기존 로직: 사전 정의된 파일 리스트 사용
     let fileList = [];
     
     if (githubPath.includes('.claude/commands/aiwf')) {
@@ -183,16 +338,11 @@ async function downloadDirectory(githubPath, localPath, spinner, messages, selec
       fileList = GLOBAL_RULES_FILES;
     } else if (githubPath.includes('rules/manual')) {
       fileList = MANUAL_RULES_FILES;
-    } else if (githubPath.includes('98_PROMPTS')) {
-      fileList = PROMPT_FILES;
-    } else if (githubPath.includes('99_TEMPLATES')) {
-      fileList = TEMPLATE_FILES;
-    } else {
-      // For unknown directories, try to download common files
-      fileList = ['README.md', 'index.md'];
     }
     
-    await downloadFileList(githubPath, localPath, fileList, spinner, messages);
+    if (fileList.length > 0) {
+      await downloadFileList(githubPath, localPath, fileList, spinner, messages);
+    }
   } catch (error) {
     throw new Error(`Failed to download directory ${githubPath}: ${error.message}`);
   }
@@ -203,8 +353,14 @@ export {
   downloadFile,
   downloadFileList,
   downloadDirectory,
+  downloadDirectoryRecursive,
+  fetchGitHubDirectory,
   GITHUB_RAW_URL,
   GITHUB_CONTENT_PREFIX,
+  GITHUB_API_URL,
+  GITHUB_OWNER,
+  GITHUB_REPO,
+  GITHUB_BRANCH,
   COMMAND_FILES,
   GLOBAL_RULES_FILES,
   MANUAL_RULES_FILES,

package/src/lib/installer.js

@@ -219,20 +219,46 @@ async function downloadManifest(languagePath, spinner, msg, debugLog) {
 async function downloadTemplates(languagePath, spinner, msg, debugLog) {
   try {
     logWithSpinner(spinner, msg.downloadingTemplates, debugLog);
+    
+    // .aiwf 전체 디렉토리를 동적으로 다운로드
+    logWithSpinner(spinner, `Downloading .aiwf directory structure...`, debugLog);
     await downloadDirectory(
-      `${GITHUB_CONTENT_PREFIX}/${languagePath}/.aiwf/98_PROMPTS`,
-      AIWF_DIRS.PROMPTS,
+      `${GITHUB_CONTENT_PREFIX}/${languagePath}/.aiwf`,
+      AIWF_DIRS.ROOT,
       spinner,
-      msg
-    );
-    await downloadDirectory(
-      `${GITHUB_CONTENT_PREFIX}/${languagePath}/.aiwf/99_TEMPLATES`,
-      AIWF_DIRS.TEMPLATES,
-      spinner,
-      msg
+      msg,
+      languagePath,
+      true // useDynamicFetch = true
     );
+    
+    logWithSpinner(spinner, `Successfully downloaded .aiwf directory`, debugLog);
   } catch (error) {
-    logWithSpinner(spinner, msg.templatesNotFound, debugLog);
+    logWithSpinner(spinner, `Error downloading .aiwf: ${error.message}`, debugLog);
+    
+    // Fallback: 개별 디렉토리 다운로드 시도
+    try {
+      logWithSpinner(spinner, `Trying individual directory downloads...`, debugLog);
+      
+      await downloadDirectory(
+        `${GITHUB_CONTENT_PREFIX}/${languagePath}/.aiwf/98_PROMPTS`,
+        AIWF_DIRS.PROMPTS,
+        spinner,
+        msg,
+        languagePath,
+        true
+      );
+      
+      await downloadDirectory(
+        `${GITHUB_CONTENT_PREFIX}/${languagePath}/.aiwf/99_TEMPLATES`,
+        AIWF_DIRS.TEMPLATES,
+        spinner,
+        msg,
+        languagePath,
+        true
+      );
+    } catch (fallbackError) {
+      logWithSpinner(spinner, msg.templatesNotFound, debugLog);
+    }
   }
 }
 
@@ -282,7 +308,8 @@ async function updateCommands(languagePath, spinner, msg, debugLog) {
       TOOL_DIRS.CLAUDE_COMMANDS,
       spinner,
       msg,
-      languagePath
+      languagePath,
+      false // commands는 기존 방식 유지 (파일 리스트 사용)
     );
   } catch (error) {
     logWithSpinner(spinner, msg.commandsNotFound, debugLog);