aiwf 0.3.5 → 0.3.7

package/src/commands/sprint-task.js

@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+
+/**
+ * 스프린트 태스크 관리 명령어
+ * 스프린트에 개별 태스크를 추가하고 관리하는 기능
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+
+// 프로젝트 루트에서 .aiwf 디렉토리 찾기
+async function findProjectRoot(startDir = process.cwd()) {
+  let currentDir = startDir;
+  
+  while (currentDir !== path.parse(currentDir).root) {
+    try {
+      const aiwfPath = path.join(currentDir, '.aiwf');
+      await fs.access(aiwfPath);
+      return currentDir;
+    } catch {
+      currentDir = path.dirname(currentDir);
+    }
+  }
+  
+  throw new Error('.aiwf 디렉토리를 찾을 수 없습니다. AIWF 프로젝트 내에서 실행해주세요.');
+}
+
+// 스프린트 존재 확인
+async function verifySprintExists(projectRoot, sprintId) {
+  const sprintsDir = path.join(projectRoot, '.aiwf', '03_SPRINTS');
+  
+  try {
+    const entries = await fs.readdir(sprintsDir);
+    const sprintDir = entries.find(entry => entry.startsWith(sprintId + '_'));
+    
+    if (!sprintDir) {
+      throw new Error(`스프린트 ${sprintId}를 찾을 수 없습니다.`);
+    }
+    
+    return path.join(sprintsDir, sprintDir);
+  } catch (error) {
+    throw new Error(`스프린트 디렉토리 읽기 실패: ${error.message}`);
+  }
+}
+
+// 다음 태스크 번호 결정
+async function getNextTaskNumber(sprintPath, sprintId) {
+  try {
+    const files = await fs.readdir(sprintPath);
+    const taskFiles = files.filter(f => f.match(/^T\d+_/));
+    
+    if (taskFiles.length === 0) {
+      return 'T01';
+    }
+    
+    const numbers = taskFiles.map(f => {
+      const match = f.match(/^T(\d+)_/);
+      return match ? parseInt(match[1]) : 0;
+    });
+    
+    const maxNumber = Math.max(...numbers);
+    return `T${String(maxNumber + 1).padStart(2, '0')}`;
+  } catch {
+    return 'T01';
+  }
+}
+
+// 태스크 파일 생성
+async function createTaskFile(sprintPath, taskNumber, sprintId, taskTitle) {
+  const timestamp = new Date().toISOString().slice(0, 16).replace('T', ' ');
+  const fileName = `${taskNumber}_${sprintId}_${taskTitle.toLowerCase().replace(/\s+/g, '_').replace(/[^a-z0-9_가-힣]/g, '')}.md`;
+  const filePath = path.join(sprintPath, fileName);
+  
+  const content = `# ${taskNumber}: ${taskTitle}
+
+**스프린트**: ${sprintId}
+**생성일**: ${timestamp}
+**상태**: pending
+**우선순위**: medium
+**예상 시간**: TBD
+
+## 개요
+
+[태스크에 대한 간단한 설명을 작성하세요]
+
+## 요구사항
+
+- [ ] [구체적인 요구사항 1]
+- [ ] [구체적인 요구사항 2]
+- [ ] [구체적인 요구사항 3]
+
+## 승인 기준
+
+- [ ] [완료 조건 1]
+- [ ] [완료 조건 2]
+- [ ] [완료 조건 3]
+
+## 기술 가이드라인
+
+- [관련 아키텍처 결정 참조]
+- [기존 코드베이스 패턴 참조]
+- [사용할 기술 스택]
+
+## 구현 노트
+
+- [구현 시 고려사항]
+- [잠재적 리스크]
+- [테스트 전략]
+
+## 참조
+
+- [관련 문서나 코드 링크]
+`;
+
+  await fs.writeFile(filePath, content);
+  return { filePath, fileName, taskNumber };
+}
+
+// 스프린트 메타 파일 업데이트
+async function updateSprintMeta(sprintPath, taskNumber, taskTitle) {
+  const files = await fs.readdir(sprintPath);
+  const metaFile = files.find(f => f.includes('sprint_meta.md'));
+  
+  if (!metaFile) {
+    console.warn(chalk.yellow('⚠️  스프린트 메타 파일을 찾을 수 없습니다.'));
+    return;
+  }
+  
+  const metaPath = path.join(sprintPath, metaFile);
+  let content = await fs.readFile(metaPath, 'utf-8');
+  
+  // 태스크 섹션 찾기 및 업데이트
+  const taskSectionRegex = /## 태스크 목록[\s\S]*?(?=##|$)/;
+  const taskMatch = content.match(taskSectionRegex);
+  
+  if (taskMatch) {
+    const newTaskLine = `- [ ] ${taskNumber}: ${taskTitle} - 상태: pending\n`;
+    const updatedSection = taskMatch[0] + newTaskLine;
+    content = content.replace(taskSectionRegex, updatedSection);
+  } else {
+    // 태스크 섹션이 없으면 추가
+    content += `\n## 태스크 목록\n\n- [ ] ${taskNumber}: ${taskTitle} - 상태: pending\n`;
+  }
+  
+  await fs.writeFile(metaPath, content);
+}
+
+// 매니페스트 업데이트
+async function updateManifest(projectRoot, sprintId, taskNumber, taskTitle) {
+  const manifestPath = path.join(projectRoot, '.aiwf', '00_PROJECT_MANIFEST.md');
+  
+  try {
+    let content = await fs.readFile(manifestPath, 'utf-8');
+    
+    // 최종 업데이트 날짜 변경
+    const dateRegex = /\*\*마지막 업데이트\*\*: \d{4}-\d{2}-\d{2}/;
+    const today = new Date().toISOString().slice(0, 10);
+    content = content.replace(dateRegex, `**마지막 업데이트**: ${today}`);
+    
+    // 활성 태스크 섹션에 추가
+    const activeTasksRegex = /## 활성 태스크[\s\S]*?### 계획됨/;
+    const match = content.match(activeTasksRegex);
+    
+    if (match) {
+      const newTaskLine = `\n- **${taskNumber}_${sprintId}**: ${taskTitle} (pending → ${today} 생성)\n`;
+      const updatedSection = match[0].replace('### 계획됨', newTaskLine + '### 계획됨');
+      content = content.replace(activeTasksRegex, updatedSection);
+    }
+    
+    // 태스크 통계 업데이트
+    const statsRegex = /- \*\*총 태스크\*\*: (\d+)/;
+    const statsMatch = content.match(statsRegex);
+    if (statsMatch) {
+      const total = parseInt(statsMatch[1]) + 1;
+      content = content.replace(statsRegex, `- **총 태스크**: ${total}`);
+    }
+    
+    await fs.writeFile(manifestPath, content);
+  } catch (error) {
+    console.warn(chalk.yellow(`⚠️  매니페스트 업데이트 실패: ${error.message}`));
+  }
+}
+
+// 메인 함수
+export async function addTaskToSprint(sprintId, taskTitle) {
+  const spinner = ora('스프린트에 태스크 추가 중...').start();
+  
+  try {
+    // 1. 프로젝트 루트 찾기
+    const projectRoot = await findProjectRoot();
+    
+    // 2. 스프린트 존재 확인
+    spinner.text = '스프린트 확인 중...';
+    const sprintPath = await verifySprintExists(projectRoot, sprintId);
+    
+    // 3. 다음 태스크 번호 결정
+    spinner.text = '태스크 번호 결정 중...';
+    const taskNumber = await getNextTaskNumber(sprintPath, sprintId);
+    
+    // 4. 태스크 파일 생성
+    spinner.text = '태스크 파일 생성 중...';
+    const { filePath, fileName, taskNumber: finalTaskNumber } = await createTaskFile(
+      sprintPath, 
+      taskNumber, 
+      sprintId, 
+      taskTitle
+    );
+    
+    // 5. 스프린트 메타 업데이트
+    spinner.text = '스프린트 메타 업데이트 중...';
+    await updateSprintMeta(sprintPath, finalTaskNumber, taskTitle);
+    
+    // 6. 매니페스트 업데이트
+    spinner.text = '프로젝트 매니페스트 업데이트 중...';
+    await updateManifest(projectRoot, sprintId, finalTaskNumber, taskTitle);
+    
+    spinner.succeed('태스크 추가 완료!');
+    
+    // 성공 메시지
+    console.log('\n' + chalk.green('✅ 태스크 추가 완료!'));
+    console.log('\n📄 생성된 파일: ' + chalk.cyan(fileName));
+    console.log('🏃 스프린트: ' + chalk.yellow(sprintId));
+    console.log('📋 태스크: ' + chalk.yellow(`${finalTaskNumber} - ${taskTitle}`));
+    console.log('⏱️  상태: ' + chalk.blue('pending'));
+    
+    console.log('\n' + chalk.bold('📝 다음 단계:'));
+    console.log('1. 태스크 파일을 열어 세부사항 작성');
+    console.log(`2. ${chalk.cyan(`/aiwf:do_task ${finalTaskNumber}`)}로 작업 시작`);
+    console.log(`3. 완료 후 ${chalk.cyan(`/aiwf:update_task_status ${finalTaskNumber} completed`)} 실행`);
+    
+    console.log('\n💡 팁: 태스크 목록 확인은 ' + chalk.cyan(`/aiwf:list_sprint_tasks ${sprintId}`));
+    
+    return { success: true, taskNumber: finalTaskNumber, filePath };
+    
+  } catch (error) {
+    spinner.fail(`태스크 추가 실패: ${error.message}`);
+    throw error;
+  }
+}
+
+// CLI 실행
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const args = process.argv.slice(2);
+  
+  if (args.length < 2) {
+    console.error(chalk.red('사용법: aiwf-sprint-task <스프린트ID> <태스크 제목>'));
+    console.error(chalk.gray('예시: aiwf-sprint-task S03 "API 성능 최적화"'));
+    process.exit(1);
+  }
+  
+  const [sprintId, ...titleParts] = args;
+  const taskTitle = titleParts.join(' ').replace(/^["']|["']$/g, '');
+  
+  addTaskToSprint(sprintId, taskTitle).catch(error => {
+    console.error(chalk.red(`오류: ${error.message}`));
+    process.exit(1);
+  });
+}
+
+export default addTaskToSprint;

package/src/lib/file-downloader.js

@@ -1,10 +1,15 @@
 import https from 'https';
 import { createWriteStream } from 'fs';
+import fs from 'fs/promises';
 import { pipeline } from 'stream/promises';
 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 = [
@@ -81,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}`));
         }
@@ -103,31 +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) {
-  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);
+async function downloadFile(url, destPath, retries = 3) {
+  // Ensure destination directory exists
+  const destDir = path.dirname(destPath);
+  await fs.mkdir(destDir, { recursive: true });
+  
+  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;
+      }
+    }
+  }
 }
 
 /**
@@ -159,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')) {
@@ -178,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}`);
   }
@@ -198,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

@@ -182,9 +182,14 @@ async function handleExistingInstallation(msg, options) {
 async function createDirectoryStructure() {
   const aiwfDirs = getAllAiwfDirectories();
 
+  // Create AIWF directories
   for (const dir of aiwfDirs) {
     await fs.mkdir(dir, { recursive: true });
   }
+
+  // Create tool-specific directories
+  await fs.mkdir(TOOL_DIRS.CURSOR_RULES, { recursive: true });
+  await fs.mkdir(TOOL_DIRS.WINDSURF_RULES, { recursive: true });
 }
 
 /**
@@ -214,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,
-      spinner,
-      msg
-    );
-    await downloadDirectory(
-      `${GITHUB_CONTENT_PREFIX}/${languagePath}/.aiwf/99_TEMPLATES`,
-      AIWF_DIRS.TEMPLATES,
+      `${GITHUB_CONTENT_PREFIX}/${languagePath}/.aiwf`,
+      AIWF_DIRS.ROOT,
       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);
+    }
   }
 }
 
@@ -277,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);
@@ -301,7 +333,7 @@ async function downloadAndProcessRules(spinner, msg, debugLog) {
   // Try to download rules/global from GitHub
   try {
     await downloadDirectory(
-      `${GITHUB_CONTENT_PREFIX}/rules/global`,
+      `rules/global`,
       tmpRulesGlobal,
       spinner,
       debugLog
@@ -310,20 +342,25 @@ async function downloadAndProcessRules(spinner, msg, debugLog) {
   } catch (error) {
     logWithSpinner(spinner, `Failed to download rules/global from GitHub, trying local files`, debugLog);
     // Fallback to local files
-    const localRulesGlobal = 'rules/global';
+    const localRulesGlobal = path.join(process.cwd(), 'rules/global');
     try {
+      logWithSpinner(spinner, `Trying to access: ${localRulesGlobal}`, debugLog);
       await fs.access(localRulesGlobal);
+      logWithSpinner(spinner, `Successfully accessed local rules/global`, debugLog);
       // Copy local files to temp directory
       await fs.mkdir(tmpRulesGlobal, { recursive: true });
       const files = await fs.readdir(localRulesGlobal);
+      logWithSpinner(spinner, `Found ${files.length} files in rules/global: ${files.join(', ')}`, debugLog);
       for (const file of files) {
         const srcPath = path.join(localRulesGlobal, file);
         const destPath = path.join(tmpRulesGlobal, file);
         await fs.copyFile(srcPath, destPath);
+        logWithSpinner(spinner, `Copied: ${file}`, debugLog);
       }
       useLocalGlobal = true;
       logWithSpinner(spinner, `Using local rules/global directory`, debugLog);
     } catch (localError) {
+      logWithSpinner(spinner, `Local rules/global error: ${localError.message}`, debugLog);
       logWithSpinner(spinner, msg.rulesGlobalNotFound, debugLog);
     }
   }
@@ -331,7 +368,7 @@ async function downloadAndProcessRules(spinner, msg, debugLog) {
   // Try to download rules/manual from GitHub
   try {
     await downloadDirectory(
-      `${GITHUB_CONTENT_PREFIX}/rules/manual`,
+      `rules/manual`,
       tmpRulesManual,
       spinner,
       debugLog
@@ -340,7 +377,7 @@ async function downloadAndProcessRules(spinner, msg, debugLog) {
   } catch (error) {
     logWithSpinner(spinner, `Failed to download rules/manual from GitHub, trying local files`, debugLog);
     // Fallback to local files
-    const localRulesManual = 'rules/manual';
+    const localRulesManual = path.join(process.cwd(), 'rules/manual');
     try {
       await fs.access(localRulesManual);
       // Copy local files to temp directory