aiwf 0.3.4 → 0.3.6

package/src/commands/create-project.js

@@ -1,12 +1,15 @@
 #!/usr/bin/env node
 
-const fs = require('fs-extra');
-const path = require('path');
-const prompts = require('prompts');
-const chalk = require('chalk');
-const ora = require('ora');
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import prompts from 'prompts';
+import chalk from 'chalk';
+import ora from 'ora';
 
-const TEMPLATES_DIR = path.join(__dirname, '../templates');
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const TEMPLATES_DIR = path.join(__dirname, '../../templates');
 
 async function createProject() {
   console.log(chalk.cyan('\n🚀 AIWF 프로젝트 생성기\n'));
@@ -148,4 +151,4 @@ if (require.main === module) {
   });
 }
 
-module.exports = { createProject };
+export { createProject };

package/src/commands/persona.js

@@ -0,0 +1,288 @@
+#!/usr/bin/env node
+
+/**
+ * AI 페르소나 명령어
+ * AI 행동 페르소나 관리 및 전환
+ */
+
+import { AIPersonaManager } from '../lib/ai-persona-manager.js';
+import path from 'path';
+import chalk from 'chalk';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+class PersonaCommand {
+  constructor() {
+    this.personaManager = null;
+  }
+
+  /**
+   * 페르소나 매니저 초기화
+   */
+  async initPersonaManager() {
+    if (!this.personaManager) {
+      this.personaManager = new AIPersonaManager({
+        personaConfigPath: path.join(process.cwd(), '.aiwf', 'personas'),
+        metricsPath: path.join(process.cwd(), '.aiwf', 'metrics'),
+        metricsEnabled: true,
+        autoDetectionEnabled: true
+      });
+      
+      await this.personaManager.init();
+    }
+    
+    return this.personaManager;
+  }
+
+  /**
+   * 페르소나 상태 표시
+   */
+  async showStatus() {
+    try {
+      // 파일에서 현재 페르소나 읽기
+      const fs = await import('fs/promises');
+      const path = await import('path');
+      const personaFile = path.join(process.cwd(), '.aiwf', 'personas', 'current.json');
+      
+      try {
+        const content = await fs.readFile(personaFile, 'utf-8');
+        const currentPersona = JSON.parse(content);
+        
+        console.log(chalk.cyan('🎭 현재 AI 페르소나 상태'));
+        console.log(chalk.gray('-'.repeat(50)));
+        console.log(`현재 페르소나: ${chalk.yellow(currentPersona.name)}`);
+        console.log(`설명: ${currentPersona.description}`);
+        console.log(`활성화 시간: ${new Date(currentPersona.activatedAt).toLocaleString('ko-KR')}`);
+        
+        const behaviors = this.getKoreanBehaviors(currentPersona.name);
+        if (behaviors.length > 0) {
+          console.log('\n주요 동작:');
+          behaviors.forEach(behavior => {
+            console.log(`  • ${behavior}`);
+          });
+        }
+
+        console.log(chalk.gray('\n' + '-'.repeat(50)));
+        console.log(chalk.green('✅ 페르소나가 활성화되어 있습니다.'));
+        
+      } catch (fileError) {
+        console.log(chalk.yellow('⚠️  현재 활성화된 페르소나가 없습니다.'));
+        console.log(chalk.gray('사용 가능한 페르소나 목록을 보려면: aiwf persona list'));
+        console.log(chalk.gray('페르소나를 설정하려면: aiwf persona set <페르소나명>'));
+      }
+      
+    } catch (error) {
+      console.error(chalk.red('❌ 페르소나 상태 확인 중 오류가 발생했습니다:'), error.message);
+      console.error(error.stack);
+    }
+  }
+
+  /**
+   * 페르소나 목록 표시
+   */
+  async listPersonas() {
+    try {
+      console.log(chalk.cyan('🎭 사용 가능한 AI 페르소나'));
+      console.log(chalk.gray('-'.repeat(50)));
+      
+      // 기본 페르소나 목록을 하드코딩으로 표시 (초기화 문제 회피)
+      const defaultPersonas = [
+        { name: 'architect', description: '시스템 설계 및 아키텍처 전문가' },
+        { name: 'developer', description: '일반 개발자 (기본값)' },
+        { name: 'reviewer', description: '코드 리뷰 및 품질 관리 전문가' },
+        { name: 'debugger', description: '디버깅 및 문제 해결 전문가' },
+        { name: 'optimizer', description: '성능 최적화 전문가' },
+        { name: 'security', description: '보안 및 취약점 분석 전문가' },
+        { name: 'documenter', description: '문서화 및 기술 작성 전문가' }
+      ];
+      
+      defaultPersonas.forEach(persona => {
+        const displayName = chalk.yellow(persona.name);
+        console.log(`  ${displayName} - ${persona.description}`);
+      });
+      
+      console.log(chalk.gray('\n' + '-'.repeat(50)));
+      console.log(chalk.gray('사용법: aiwf persona set <페르소나명>'));
+      
+    } catch (error) {
+      console.error(chalk.red('❌ 페르소나 목록 조회 중 오류가 발생했습니다:'), error.message);
+      console.error(error.stack);
+    }
+  }
+
+  /**
+   * 페르소나 전환
+   */
+  async setPersona(personaName) {
+    if (!personaName) {
+      console.error(chalk.red('❌ 페르소나 이름을 지정해주세요.'));
+      console.log(chalk.gray('사용법: aiwf persona set <페르소나명>'));
+      console.log(chalk.gray('사용 가능한 페르소나: aiwf persona list'));
+      return;
+    }
+
+    try {
+      // 유효한 페르소나인지 확인
+      const validPersonas = ['architect', 'developer', 'reviewer', 'debugger', 'optimizer', 'security', 'documenter'];
+      
+      if (!validPersonas.includes(personaName)) {
+        console.error(chalk.red(`❌ 페르소나 '${personaName}'를 찾을 수 없습니다.`));
+        console.log(chalk.gray('사용 가능한 페르소나: aiwf persona list'));
+        return;
+      }
+
+      // 간단한 페르소나 설정 (파일 기반)
+      const fs = await import('fs/promises');
+      const path = await import('path');
+      const personaDir = path.join(process.cwd(), '.aiwf', 'personas');
+      
+      // 디렉토리 생성
+      await fs.mkdir(personaDir, { recursive: true });
+      
+      // 현재 페르소나 저장
+      const personaConfig = {
+        name: personaName,
+        description: this.getKoreanDescription(personaName),
+        activatedAt: new Date().toISOString()
+      };
+      
+      await fs.writeFile(
+        path.join(personaDir, 'current.json'),
+        JSON.stringify(personaConfig, null, 2)
+      );
+      
+      console.log(chalk.green('🎭 AI 페르소나 활성화 완료'));
+      console.log(chalk.gray('-'.repeat(50)));
+      console.log(`현재 페르소나: ${chalk.yellow(personaName)}`);
+      console.log(`전문 분야: ${this.getKoreanDescription(personaName)}`);
+      console.log(chalk.gray('-'.repeat(50)));
+      console.log(chalk.green('✅ 페르소나가 성공적으로 활성화되었습니다.'));
+      
+    } catch (error) {
+      console.error(chalk.red('❌ 페르소나 전환 중 오류가 발생했습니다:'), error.message);
+      console.error(error.stack);
+    }
+  }
+
+  /**
+   * 페르소나 리셋
+   */
+  async resetPersona() {
+    try {
+      // 기본 페르소나(developer)로 리셋
+      await this.setPersona('developer');
+      console.log(chalk.green('🔄 페르소나가 기본값(developer)으로 리셋되었습니다.'));
+      
+    } catch (error) {
+      console.error(chalk.red('❌ 페르소나 리셋 중 오류가 발생했습니다:'), error.message);
+      console.error(error.stack);
+    }
+  }
+
+  /**
+   * 명령어 실행
+   */
+  async execute(args) {
+    const [subcommand, ...restArgs] = args;
+
+    switch (subcommand) {
+      case 'status':
+        await this.showStatus();
+        break;
+      case 'list':
+        await this.listPersonas();
+        break;
+      case 'set':
+        await this.setPersona(restArgs[0]);
+        break;
+      case 'reset':
+        await this.resetPersona();
+        break;
+      default:
+        this.showHelp();
+        break;
+    }
+  }
+
+  /**
+   * 도움말 표시
+   */
+  showHelp() {
+    console.log(chalk.cyan('🎭 AIWF 페르소나 관리'));
+    console.log(chalk.gray('-'.repeat(50)));
+    console.log('사용법: aiwf persona <명령어> [옵션]');
+    console.log('');
+    console.log('명령어:');
+    console.log('  status              현재 페르소나 상태 표시');
+    console.log('  list                사용 가능한 페르소나 목록');
+    console.log('  set <페르소나명>     특정 페르소나로 전환');
+    console.log('  reset               기본 페르소나로 리셋');
+    console.log('');
+    console.log('예시:');
+    console.log('  aiwf persona status');
+    console.log('  aiwf persona list');
+    console.log('  aiwf persona set architect');
+    console.log('  aiwf persona reset');
+  }
+
+  /**
+   * 한국어 설명 가져오기
+   */
+  getKoreanDescription(persona) {
+    const descriptions = {
+      architect: '시스템 설계 및 아키텍처 전문가',
+      developer: '일반 개발자 (기본값)',
+      reviewer: '코드 리뷰 및 품질 관리 전문가',
+      debugger: '디버깅 및 문제 해결 전문가',
+      optimizer: '성능 최적화 전문가',
+      security: '보안 및 취약점 분석 전문가',
+      devops: 'DevOps 및 인프라 관리 전문가',
+      tester: '테스트 및 QA 전문가',
+      documenter: '문서화 및 기술 작성 전문가',
+      mentor: '멘토링 및 교육 전문가'
+    };
+    
+    return descriptions[persona] || '설명 없음';
+  }
+
+  /**
+   * 한국어 동작 설명 가져오기
+   */
+  getKoreanBehaviors(persona) {
+    const behaviors = {
+      architect: [
+        '큰 그림과 전체 시스템 구조에 집중',
+        '확장성과 유지보수성 우선시',
+        '디자인 패턴과 아키텍처 원칙 적용',
+        '통합 지점과 인터페이스 고려'
+      ],
+      developer: [
+        '실용적이고 효율적인 코드 작성',
+        '베스트 프랙티스 적용',
+        '가독성과 유지보수성 중시'
+      ],
+      reviewer: [
+        '코드 품질과 표준 준수 확인',
+        '잠재적 버그와 개선점 식별',
+        '성능과 보안 측면 검토'
+      ],
+      debugger: [
+        '문제의 근본 원인 분석',
+        '체계적인 디버깅 접근',
+        '재현 가능한 테스트 케이스 생성'
+      ],
+      optimizer: [
+        '성능 병목 지점 식별',
+        '메모리 사용량 최적화',
+        '알고리즘 효율성 개선'
+      ]
+    };
+    
+    return behaviors[persona] || ['기본 동작'];
+  }
+}
+
+export default PersonaCommand;

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,5 +1,6 @@
 import https from 'https';
 import { createWriteStream } from 'fs';
+import fs from 'fs/promises';
 import { pipeline } from 'stream/promises';
 import path from 'path';
 
@@ -109,6 +110,10 @@ async function fetchContent(url) {
  * @returns {Promise<void>}
  */
 async function downloadFile(url, destPath) {
+  // 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) {

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 });
 }
 
 /**
@@ -301,7 +306,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 +315,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 +341,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 +350,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