aiwf 0.3.22 → 0.4.0

package/src/utils/language-utils.js

@@ -1,331 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * 언어 관리 유틸리티 모듈
- * AIWF 프레임워크의 언어 감지, 설정 저장/복원, 라우팅을 담당합니다.
- */
-
-import fs from 'fs/promises';
-import path from 'path';
-import { FILES } from './paths.js';
-
-// 지원되는 언어 목록
-export const SUPPORTED_LANGUAGES = ['ko', 'en'];
-export const DEFAULT_LANGUAGE = 'en';
-export const LANGUAGE_CONFIG_PATH = FILES.LANGUAGE_CONFIG;
-
-/**
- * 언어 감지 알고리즘
- * 1. 사용자 명시적 설정 (.aiwf/config/language.json)
- * 2. 환경 변수 (LANG, LC_ALL)
- * 3. 시스템 로케일 (process.env.LANG)
- * 4. 폴백: 영어 (en)
- */
-export async function detectLanguage() {
-    try {
-        // 1. 사용자 설정 확인
-        const userConfig = await loadUserLanguageConfig();
-        if (userConfig?.language && SUPPORTED_LANGUAGES.includes(userConfig.language)) {
-            return userConfig.language;
-        }
-        
-        // 2. 환경 변수 확인
-        const envLang = process.env.LANG || process.env.LC_ALL;
-        if (envLang) {
-            // 한국어 로케일 감지
-            if (envLang.toLowerCase().startsWith('ko')) {
-                return 'ko';
-            }
-            // 영어 로케일 감지
-            if (envLang.toLowerCase().startsWith('en')) {
-                return 'en';
-            }
-        }
-        
-        // 3. 폴백: 기본 언어
-        return DEFAULT_LANGUAGE;
-    } catch (error) {
-        console.warn(`언어 감지 중 오류 발생: ${error.message}`);
-        return DEFAULT_LANGUAGE;
-    }
-}
-
-/**
- * 사용자 언어 설정 로드
- */
-export async function loadUserLanguageConfig() {
-    try {
-        const configExists = await fs.access(LANGUAGE_CONFIG_PATH).then(() => true).catch(() => false);
-        if (!configExists) {
-            return null;
-        }
-        
-        const configContent = await fs.readFile(LANGUAGE_CONFIG_PATH, 'utf8');
-        const config = JSON.parse(configContent);
-        
-        // 설정 유효성 검증
-        if (config.language && SUPPORTED_LANGUAGES.includes(config.language)) {
-            return config;
-        }
-        
-        return null;
-    } catch (error) {
-        console.warn(`언어 설정 로드 중 오류 발생: ${error.message}`);
-        return null;
-    }
-}
-
-/**
- * 사용자 언어 설정 저장
- */
-export async function saveUserLanguageConfig(language, options = {}) {
-    try {
-        // 언어 유효성 검증
-        if (!SUPPORTED_LANGUAGES.includes(language)) {
-            throw new Error(`지원되지 않는 언어: ${language}. 지원 언어: ${SUPPORTED_LANGUAGES.join(', ')}`);
-        }
-        
-        // 설정 디렉토리 생성
-        const configDir = path.dirname(LANGUAGE_CONFIG_PATH);
-        await fs.mkdir(configDir, { recursive: true });
-        
-        // 설정 객체 생성
-        const config = {
-            language: language,
-            auto_detect: options.auto_detect !== undefined ? options.auto_detect : true,
-            last_updated: new Date().toISOString(),
-            fallback: options.fallback || DEFAULT_LANGUAGE
-        };
-        
-        // 설정 파일 저장
-        await fs.writeFile(LANGUAGE_CONFIG_PATH, JSON.stringify(config, null, 2), 'utf8');
-        
-        return config;
-    } catch (error) {
-        console.error(`언어 설정 저장 중 오류 발생: ${error.message}`);
-        throw error;
-    }
-}
-
-/**
- * 명령어 파일 경로 라우팅
- * 언어별 명령어 파일 경로를 동적으로 생성합니다.
- */
-export function getCommandPath(commandName, language = null) {
-    // 언어가 지정되지 않은 경우 현재 언어 사용
-    if (!language) {
-        language = DEFAULT_LANGUAGE; // 동기 버전에서는 기본 언어 사용
-    }
-    
-    // 언어 유효성 검증
-    if (!SUPPORTED_LANGUAGES.includes(language)) {
-        language = DEFAULT_LANGUAGE;
-    }
-    
-    // 한국어 명령어 경로
-    if (language === 'ko') {
-        return `claude-code/aiwf/ko/.claude/commands/aiwf/${commandName}.md`;
-    }
-    
-    // 영어 명령어 경로 (기본)
-    return `claude-code/aiwf/en/.claude/commands/aiwf/${commandName}.md`;
-}
-
-/**
- * 명령어 파일 존재 여부 확인 및 폴백
- */
-export async function resolveCommandPath(commandName, preferredLanguage = null) {
-    try {
-        const language = preferredLanguage || await detectLanguage();
-        
-        // 선호 언어로 명령어 파일 경로 생성
-        let commandPath = getCommandPath(commandName, language);
-        
-        // 파일 존재 여부 확인
-        const exists = await fs.access(commandPath).then(() => true).catch(() => false);
-        if (exists) {
-            return {
-                path: commandPath,
-                language: language,
-                fallback: false
-            };
-        }
-        
-        // 폴백 언어로 재시도
-        const fallbackLanguage = language === 'ko' ? 'en' : 'ko';
-        commandPath = getCommandPath(commandName, fallbackLanguage);
-        
-        const fallbackExists = await fs.access(commandPath).then(() => true).catch(() => false);
-        if (fallbackExists) {
-            return {
-                path: commandPath,
-                language: fallbackLanguage,
-                fallback: true
-            };
-        }
-        
-        // 둘 다 없는 경우
-        return {
-            path: null,
-            language: null,
-            fallback: false,
-            error: `명령어 파일을 찾을 수 없습니다: ${commandName}`
-        };
-        
-    } catch (error) {
-        return {
-            path: null,
-            language: null,
-            fallback: false,
-            error: `명령어 경로 해결 중 오류: ${error.message}`
-        };
-    }
-}
-
-/**
- * 템플릿 파일 경로 라우팅
- */
-export function getTemplatePath(templateName, language = null) {
-    if (!language) {
-        language = DEFAULT_LANGUAGE;
-    }
-    
-    if (!SUPPORTED_LANGUAGES.includes(language)) {
-        language = DEFAULT_LANGUAGE;
-    }
-    
-    return `.aiwf/99_TEMPLATES/${language}/${templateName}`;
-}
-
-/**
- * 다국어 에러 메시지 시스템
- */
-export const ERROR_MESSAGES = {
-    ko: {
-        LANGUAGE_NOT_SUPPORTED: '지원되지 않는 언어입니다',
-        CONFIG_LOAD_FAILED: '언어 설정을 불러올 수 없습니다',
-        CONFIG_SAVE_FAILED: '언어 설정을 저장할 수 없습니다',
-        COMMAND_NOT_FOUND: '명령어를 찾을 수 없습니다',
-        TEMPLATE_NOT_FOUND: '템플릿을 찾을 수 없습니다',
-        LANGUAGE_SWITCH_SUCCESS: '언어가 성공적으로 변경되었습니다',
-        LANGUAGE_SWITCH_FAILED: '언어 변경에 실패했습니다'
-    },
-    en: {
-        LANGUAGE_NOT_SUPPORTED: 'Language not supported',
-        CONFIG_LOAD_FAILED: 'Failed to load language configuration',
-        CONFIG_SAVE_FAILED: 'Failed to save language configuration',
-        COMMAND_NOT_FOUND: 'Command not found',
-        TEMPLATE_NOT_FOUND: 'Template not found',
-        LANGUAGE_SWITCH_SUCCESS: 'Language changed successfully',
-        LANGUAGE_SWITCH_FAILED: 'Failed to change language'
-    }
-};
-
-/**
- * 다국어 메시지 가져오기
- */
-export function getLocalizedMessage(messageKey, language = null) {
-    if (!language) {
-        language = DEFAULT_LANGUAGE;
-    }
-    
-    if (!SUPPORTED_LANGUAGES.includes(language)) {
-        language = DEFAULT_LANGUAGE;
-    }
-    
-    return ERROR_MESSAGES[language]?.[messageKey] || ERROR_MESSAGES[DEFAULT_LANGUAGE]?.[messageKey] || messageKey;
-}
-
-/**
- * 언어 전환 함수
- */
-export async function switchLanguage(newLanguage) {
-    try {
-        // 언어 유효성 검증
-        if (!SUPPORTED_LANGUAGES.includes(newLanguage)) {
-            throw new Error(`지원되지 않는 언어: ${newLanguage}. 지원 언어: ${SUPPORTED_LANGUAGES.join(', ')}`);
-        }
-        
-        // 현재 언어 설정 로드
-        const currentConfig = await loadUserLanguageConfig() || {};
-        
-        // 새 언어로 설정 저장
-        const newConfig = await saveUserLanguageConfig(newLanguage, {
-            autoDetect: currentConfig.auto_detect,
-            fallback: currentConfig.fallback
-        });
-        
-        return {
-            success: true,
-            previousLanguage: currentConfig.language || DEFAULT_LANGUAGE,
-            newLanguage: newLanguage,
-            message: getLocalizedMessage('LANGUAGE_SWITCH_SUCCESS', newLanguage)
-        };
-        
-    } catch (error) {
-        return {
-            success: false,
-            error: error.message,
-            message: getLocalizedMessage('LANGUAGE_SWITCH_FAILED')
-        };
-    }
-}
-
-/**
- * 언어 설정 상태 확인
- */
-export async function getLanguageStatus() {
-    try {
-        const detectedLanguage = await detectLanguage();
-        const userConfig = await loadUserLanguageConfig();
-        
-        return {
-            detectedLanguage: detectedLanguage,
-            configuredLanguage: userConfig?.language || null,
-            effectiveLanguage: userConfig?.language || detectedLanguage,
-            autoDetect: userConfig?.auto_detect !== false,
-            fallbackLanguage: userConfig?.fallback || DEFAULT_LANGUAGE,
-            supportedLanguages: SUPPORTED_LANGUAGES,
-            configPath: LANGUAGE_CONFIG_PATH
-        };
-    } catch (error) {
-        return {
-            detectedLanguage: DEFAULT_LANGUAGE,
-            configuredLanguage: null,
-            effectiveLanguage: DEFAULT_LANGUAGE,
-            autoDetect: true,
-            fallbackLanguage: DEFAULT_LANGUAGE,
-            supportedLanguages: SUPPORTED_LANGUAGES,
-            configPath: LANGUAGE_CONFIG_PATH,
-            error: error.message
-        };
-    }
-}
-
-/**
- * 언어별 설치 경로 생성
- */
-export function getInstallationLanguagePath(language) {
-    if (!SUPPORTED_LANGUAGES.includes(language)) {
-        language = DEFAULT_LANGUAGE;
-    }
-    
-    return language;
-}
-
-// 기본 내보내기
-export default {
-    detectLanguage,
-    loadUserLanguageConfig,
-    saveUserLanguageConfig,
-    getCommandPath,
-    resolveCommandPath,
-    getTemplatePath,
-    getLocalizedMessage,
-    switchLanguage,
-    getLanguageStatus,
-    getInstallationLanguagePath,
-    SUPPORTED_LANGUAGES,
-    DEFAULT_LANGUAGE,
-    ERROR_MESSAGES
-};

package/src/utils/messages.js

@@ -1,166 +0,0 @@
-/**
- * Localized messages for AIWF installer
- */
-export const messages = {
-  ko: {
-    welcome: '\n🎉 AIWF에 오신 것을 환영합니다!\n',
-    description: '이 설치 프로그램은 AIWF AI 프롬프트 프레임워크를 설정합니다',
-    optimized: '특별히 Claude Code 에 최적화 되어있습니다.\n',
-    selectLanguage: 'Please select language / 언어를 선택해주세요:',
-    korean: '한국어 (Korean)',
-    english: 'English',
-    existingDetected: '기존 AIWF 설치가 감지되었습니다. 무엇을 하시겠습니까?',
-    updateOption: '업데이트 (명령어와 문서만 업데이트하고 작업 내용은 보존)',
-    reinstallOption: '완전 재설치 (모든 내용을 새로 설치, 기존 프로젝트 덮어쓰기)',
-    skipOption: '설치 건너뛰기',
-    cancelOption: '취소',
-    projectDetected: '기존 프로젝트가 감지되었습니다. 프로젝트 파일을 어떻게 처리하시겠습니까?',
-    preserveProject: '프로젝트 보존 (기존 프로젝트 파일 유지)',
-    overwriteProject: '덮어쓰기 (새로 설치하고 기존 프로젝트 삭제)',
-    checkingProject: '기존 프로젝트 확인 중...',
-    projectFound: '기존 프로젝트가 발견되었습니다:',
-    projectPreserved: '💾 프로젝트가 보존되었습니다.',
-    projectOverwritten: '🔄 프로젝트가 새로 설치되었습니다.',
-    installCancelled: '\n설치가 취소되었습니다.',
-    backingUp: '기존 명령어 및 문서 백업 중...',
-    fetching: 'GitHub에서 AIWF 프레임워크를 가져오는 중...',
-    downloading: 'AIWF 프레임워크 파일을 다운로드하는 중...',
-    updatingDocs: '문서를 업데이트하는 중...',
-    downloadingCommands: 'AIWF 명령어를 새로 다운로드하는 중...',
-    updateSuccess: '✅ AIWF 프레임워크가 성공적으로 업데이트되었습니다!',
-    installSuccess: '✅ AIWF 프레임워크가 성공적으로 설치되었습니다!',
-    enjoy: '\nEnjoy AIWF! 🚀\n',
-    backupComplete: '{count}개 파일 백업 완료 (*.bak)',
-    noFilesToBackup: '백업할 기존 파일이 없습니다',
-    backupFailed: '백업 실패',
-    downloadingFile: '{path} 다운로드 중...',
-    downloadingTemplates: '템플릿 디렉토리를 다운로드 중...',
-    templatesNotFound: '템플릿 디렉토리를 찾을 수 없어 건너뜁니다...',
-    deletingOldCommands: '기존 AIWF 명령어 폴더를 삭제하는 중...',
-    commandsNotFound: '명령어 디렉토리를 찾을 수 없어 건너뜁니다...',
-    downloadingRulesGlobal: 'rules/global 폴더를 다운로드 중...',
-    rulesGlobalNotFound: 'rules/global 폴더를 찾을 수 없어 건너뜁니다...',
-    downloadingRulesManual: 'rules/manual 폴더를 다운로드 중...',
-    rulesManualNotFound: 'rules/manual 폴더를 찾을 수 없어 건너뜁니다...',
-    updateHistory: '🔄 업데이트 내역:',
-    updatedCommands: '내의 명령어',
-    updatedDocs: '문서 (CLAUDE.md 파일)',
-    workPreserved: '💾 작업 내용은 보존되었습니다:',
-    allFilesPreserved: '모든 작업, 스프린트, 및 프로젝트 파일이 변경되지 않음',
-    backupCreated: '백업은 *.bak 파일로 만들어짐',
-    structureCreated: '📁 생성된 구조:',
-    aiwfRoot: '프로젝트 관리 루트',
-    claudeCommands: 'Claude 사용자 명령어',
-    nextSteps: '🚀 다음 단계:',
-    nextStep1: 'Claude Code에서 이 프로젝트를 엽니다',
-    nextStep2: '/aiwf_<command> 명령어를 사용하여 프로젝트를 관리하세요',
-    nextStep3: '/aiwf_initialize를 실행하여 프로젝트를 설정하세요',
-    gettingStarted: '✨ 시작하려면:',
-    startStep1: '새 터미널을 열거나 쉘 프로필을 소싱하세요 (예: source ~/.zshrc)',
-    startStep2: '다음을 실행하세요: claude 를 실행하여 사용 가능한 명령어를 확인하세요.',
-    checkDocs: '자세한 내용은 .aiwf 디렉토리의 문서를 확인하세요.',
-    updateFailed: '업데이트 실패',
-    installFailed: '설치 실패',
-    noBackupFound: '복원할 백업 폴더가 없습니다.',
-    restoringFromBackup: '백업에서 복원 중...',
-    restoreSuccess: '성공적으로 복원되었습니다.',
-    restoreFailed: '복원에 실패했습니다.',
-    cannotRestore: '파일을 복원할 수 없습니다. 수동 확인이 필요합니다.',
-    checkingInstallation: 'AIWF 설치 상태를 확인하는 중...',
-    creatingDirectories: 'AIWF 디렉토리 구조를 생성하는 중...',
-    restoringBackup: '백업에서 파일을 복원하는 중...',
-    backupRestored: '{count}개 파일이 복원되었습니다',
-    checkingExistingTools: '기존 도구 디렉토리를 확인하는 중...',
-    foundExistingCursor: 'Cursor 규칙 파일이 발견되었습니다',
-    foundExistingWindsurf: 'Windsurf 규칙 파일이 발견되었습니다',
-    backingUpToolFiles: '기존 도구 파일을 백업하는 중...',
-    toolBackupCreated: '도구 파일 백업이 생성되었습니다',
-    installingToolRules: '도구 규칙을 설치하는 중...',
-    toolRulesInstalled: '도구 규칙이 성공적으로 설치되었습니다',
-  },
-  en: {
-    welcome: '\n🎉 Welcome to AIWF!\n',
-    description: 'This installer sets up the AIWF AI prompt framework',
-    optimized: 'Specially optimized for Claude Code.\n',
-    selectLanguage: 'Please select language / 언어를 선택해주세요:',
-    korean: '한국어 (Korean)',
-    english: 'English',
-    existingDetected: 'Existing AIWF installation detected. What would you like to do?',
-    updateOption: 'Update (Update commands and docs only, preserve work content)',
-    reinstallOption: 'Complete reinstall (Install everything fresh, overwrite existing project)',
-    skipOption: 'Skip installation',
-    cancelOption: 'Cancel',
-    projectDetected: 'Existing project detected. How would you like to handle project files?',
-    preserveProject: 'Preserve project (Keep existing project files)',
-    overwriteProject: 'Overwrite (Fresh install and remove existing project)',
-    checkingProject: 'Checking for existing project...',
-    projectFound: 'Existing project found:',
-    projectPreserved: '💾 Project has been preserved.',
-    projectOverwritten: '🔄 Project has been freshly installed.',
-    installCancelled: '\nInstallation cancelled.',
-    backingUp: 'Backing up existing commands and documents...',
-    fetching: 'Fetching AIWF framework from GitHub...',
-    downloading: 'Downloading AIWF framework files...',
-    updatingDocs: 'Updating documentation...',
-    downloadingCommands: 'Downloading AIWF commands...',
-    updateSuccess: '✅ AIWF framework updated successfully!',
-    installSuccess: '✅ AIWF framework installed successfully!',
-    enjoy: '\nEnjoy AIWF! 🚀\n',
-    backupComplete: '{count} files backed up (*.bak)',
-    noFilesToBackup: 'No existing files to backup',
-    backupFailed: 'Backup failed',
-    downloadingFile: 'Downloading {path}...',
-    downloadingTemplates: 'Downloading template directories...',
-    templatesNotFound: 'Template directories not found, skipping...',
-    deletingOldCommands: 'Deleting existing AIWF commands folder...',
-    commandsNotFound: 'Commands directory not found, skipping...',
-    downloadingRulesGlobal: 'Downloading rules/global folder...',
-    rulesGlobalNotFound: 'rules/global folder not found, skipping...',
-    downloadingRulesManual: 'Downloading rules/manual folder...',
-    rulesManualNotFound: 'rules/manual folder not found, skipping...',
-    updateHistory: '🔄 Update History:',
-    updatedCommands: '/ commands',
-    updatedDocs: 'Documentation (CLAUDE.md files)',
-    workPreserved: '💾 Work preserved:',
-    allFilesPreserved: 'All work, sprints, and project files unchanged',
-    backupCreated: 'Backups created as *.bak files',
-    structureCreated: '📁 Structure created:',
-    aiwfRoot: 'Project management root',
-    claudeCommands: 'Claude user commands',
-    nextSteps: '🚀 Next steps:',
-    nextStep1: 'Open this project in Claude Code',
-    nextStep2: 'Use /aiwf_<command> commands to manage your project',
-    nextStep3: 'Run /aiwf_initialize to set up your project',
-    gettingStarted: '✨ Getting started:',
-    startStep1: 'Open a new terminal or source your shell profile (e.g. source ~/.zshrc)',
-    startStep2: 'Run: claude to see available commands.',
-    checkDocs: 'For more details, check the documentation in the .aiwf directory.',
-    updateFailed: 'Update failed',
-    installFailed: 'Installation failed',
-    noBackupFound: 'No backup folder found to restore.',
-    restoringFromBackup: 'Restoring from backup...',
-    restoreSuccess: 'Successfully restored.',
-    restoreFailed: 'Restore failed.',
-    cannotRestore: 'Cannot restore file. Manual verification required.',
-    checkingInstallation: 'Checking AIWF installation status...',
-    creatingDirectories: 'Creating AIWF directory structure...',
-    restoringBackup: 'Restoring files from backup...',
-    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',
-  }
-};
-
-/**
- * Get messages for a specific language
- * @param {string} language - Language code ('ko' or 'en')
- * @returns {Object} Messages object for the specified language
- */
-export function getMessages(language) {
-  return messages[language] || messages.en;
-}

package/src/utils/paths.js

@@ -1,112 +0,0 @@
-/**
- * AIWF Directory Paths Configuration
- * Central location for all directory paths used in the AIWF framework
- */
-
-import path from 'path';
-import os from 'os';
-
-// Base directories
-export const BASE_DIRS = {
-  AIWF: '.aiwf',
-  CLAUDE: '.claude',
-  GEMINI: '.gemini',
-  CURSOR: '.cursor',
-  WINDSURF: '.windsurf'
-};
-
-// AIWF subdirectories
-export const AIWF_DIRS = {
-  ROOT: BASE_DIRS.AIWF,
-  PROJECT_DOCS: path.join(BASE_DIRS.AIWF, '01_PROJECT_DOCS'),
-  REQUIREMENTS: path.join(BASE_DIRS.AIWF, '02_REQUIREMENTS'),
-  SPRINTS: path.join(BASE_DIRS.AIWF, '03_SPRINTS'),
-  GENERAL_TASKS: path.join(BASE_DIRS.AIWF, '04_GENERAL_TASKS'),
-  ARCHITECTURAL_DECISIONS: path.join(BASE_DIRS.AIWF, '05_ARCHITECTURAL_DECISIONS'),
-  STATE_OF_PROJECT: path.join(BASE_DIRS.AIWF, '10_STATE_OF_PROJECT'),
-  PROMPTS: path.join(BASE_DIRS.AIWF, '98_PROMPTS'),
-  TEMPLATES: path.join(BASE_DIRS.AIWF, '99_TEMPLATES'),
-  CACHE: path.join(BASE_DIRS.AIWF, 'cache'),
-  METRICS: path.join(BASE_DIRS.AIWF, 'metrics'),
-  CONFIG: path.join(BASE_DIRS.AIWF, 'config'),
-  PERSONAS: path.join(BASE_DIRS.AIWF, 'personas'),
-  AI_TOOLS: path.join(BASE_DIRS.AIWF, 'ai-tools'),
-  CONTEXT_CACHE: path.join(BASE_DIRS.AIWF, 'cache', 'context')
-};
-
-// Tool-specific directories
-export const TOOL_DIRS = {
-  CLAUDE_COMMANDS: path.join(BASE_DIRS.CLAUDE, 'commands', 'aiwf'),
-  CLAUDE_AGENTS: path.join(BASE_DIRS.CLAUDE, 'agents'),
-  GEMINI_PROMPTS: path.join(BASE_DIRS.GEMINI, 'prompts', 'aiwf'),
-  CURSOR_RULES: path.join(BASE_DIRS.CURSOR, 'rules'),
-  WINDSURF_RULES: path.join(BASE_DIRS.WINDSURF, 'rules')
-};
-
-// Files
-export const FILES = {
-  INSTALLED_FLAG: path.join(AIWF_DIRS.ROOT, 'installed.flag'),
-  PROJECT_MANIFEST: path.join(AIWF_DIRS.ROOT, '00_PROJECT_MANIFEST.md'),
-  LANGUAGE_CONFIG: path.join(AIWF_DIRS.CONFIG, 'language.json'),
-  CLAUDE_MD: {
-    ROOT: path.join(AIWF_DIRS.ROOT, 'CLAUDE.md'),
-    REQUIREMENTS: path.join(AIWF_DIRS.REQUIREMENTS, 'CLAUDE.md'),
-    SPRINTS: path.join(AIWF_DIRS.SPRINTS, 'CLAUDE.md'),
-    GENERAL_TASKS: path.join(AIWF_DIRS.GENERAL_TASKS, 'CLAUDE.md')
-  }
-};
-
-
-// User cache directory (for global cache)
-export const USER_CACHE_DIR = path.join(
-  os.homedir(),
-  BASE_DIRS.AIWF,
-  'cache'
-);
-
-// Get all AIWF directories as array
-export function getAllAiwfDirectories() {
-  return [
-    AIWF_DIRS.ROOT,
-    AIWF_DIRS.PROJECT_DOCS,
-    AIWF_DIRS.REQUIREMENTS,
-    AIWF_DIRS.SPRINTS,
-    AIWF_DIRS.GENERAL_TASKS,
-    AIWF_DIRS.ARCHITECTURAL_DECISIONS,
-    AIWF_DIRS.STATE_OF_PROJECT,
-    AIWF_DIRS.PROMPTS,
-    AIWF_DIRS.TEMPLATES
-  ];
-}
-
-// Get all CLAUDE.md files as array
-export function getAllClaudeMdFiles() {
-  return Object.values(FILES.CLAUDE_MD);
-}
-
-// Get tool directory by name
-export function getToolDirectory(tool) {
-  const mapping = {
-    claudeCode: TOOL_DIRS.CLAUDE_COMMANDS,
-    'claude-code': TOOL_DIRS.CLAUDE_COMMANDS,
-    geminiCLI: TOOL_DIRS.GEMINI_PROMPTS,
-    'gemini-cli': TOOL_DIRS.GEMINI_PROMPTS,
-    cursor: TOOL_DIRS.CURSOR_RULES,
-    windsurf: TOOL_DIRS.WINDSURF_RULES,
-    aiwf: AIWF_DIRS.ROOT
-  };
-  return mapping[tool] || null;
-}
-
-
-// Export all for convenience
-export default {
-  BASE_DIRS,
-  AIWF_DIRS,
-  TOOL_DIRS,
-  FILES,
-  USER_CACHE_DIR,
-  getAllAiwfDirectories,
-  getAllClaudeMdFiles,
-  getToolDirectory
-};