aiwf 0.1.0 → 0.3.1

package/jest.config.js

@@ -0,0 +1,4 @@
+export default {
+  testEnvironment: 'node',
+  testMatch: ['**/__tests__/**/*.js', '**/?(*.)+(spec|test).js']
+};

package/language-cli.js

@@ -0,0 +1,279 @@
+#!/usr/bin/env node
+
+/**
+ * 언어 관리 CLI 명령어
+ * AIWF 프레임워크의 언어 설정을 관리하는 CLI 도구입니다.
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import prompts from 'prompts';
+import {
+    detectLanguage,
+    loadUserLanguageConfig,
+    saveUserLanguageConfig,
+    switchLanguage,
+    getLanguageStatus,
+    getLocalizedMessage,
+    SUPPORTED_LANGUAGES,
+    DEFAULT_LANGUAGE
+} from './language-utils.js';
+
+const program = new Command();
+
+// 다국어 CLI 메시지
+const CLI_MESSAGES = {
+    ko: {
+        LANGUAGE_STATUS_TITLE: '🌐 AIWF 언어 설정 상태',
+        DETECTED_LANGUAGE: '감지된 언어',
+        CONFIGURED_LANGUAGE: '설정된 언어',
+        EFFECTIVE_LANGUAGE: '사용 중인 언어',
+        AUTO_DETECT: '자동 감지',
+        FALLBACK_LANGUAGE: '폴백 언어',
+        SUPPORTED_LANGUAGES: '지원 언어',
+        CONFIG_PATH: '설정 파일 경로',
+        ENABLED: '활성화',
+        DISABLED: '비활성화',
+        NOT_SET: '설정되지 않음',
+        SELECT_LANGUAGE: '사용할 언어를 선택하세요:',
+        ENABLE_AUTO_DETECT: '자동 언어 감지를 활성화하시겠습니까?',
+        LANGUAGE_CHANGED: '언어가 성공적으로 변경되었습니다',
+        OPERATION_CANCELLED: '작업이 취소되었습니다',
+        CURRENT_LANGUAGE: '현재 언어',
+        PREVIOUS_LANGUAGE: '이전 언어',
+        NEW_LANGUAGE: '새 언어'
+    },
+    en: {
+        LANGUAGE_STATUS_TITLE: '🌐 AIWF Language Configuration Status',
+        DETECTED_LANGUAGE: 'Detected Language',
+        CONFIGURED_LANGUAGE: 'Configured Language',
+        EFFECTIVE_LANGUAGE: 'Effective Language',
+        AUTO_DETECT: 'Auto Detection',
+        FALLBACK_LANGUAGE: 'Fallback Language',
+        SUPPORTED_LANGUAGES: 'Supported Languages',
+        CONFIG_PATH: 'Configuration Path',
+        ENABLED: 'Enabled',
+        DISABLED: 'Disabled',
+        NOT_SET: 'Not Set',
+        SELECT_LANGUAGE: 'Select language to use:',
+        ENABLE_AUTO_DETECT: 'Enable automatic language detection?',
+        LANGUAGE_CHANGED: 'Language changed successfully',
+        OPERATION_CANCELLED: 'Operation cancelled',
+        CURRENT_LANGUAGE: 'Current Language',
+        PREVIOUS_LANGUAGE: 'Previous Language',
+        NEW_LANGUAGE: 'New Language'
+    }
+};
+
+/**
+ * 로컬라이즈된 CLI 메시지 가져오기
+ */
+function getCliMessage(key, language = DEFAULT_LANGUAGE) {
+    return CLI_MESSAGES[language]?.[key] || CLI_MESSAGES[DEFAULT_LANGUAGE]?.[key] || key;
+}
+
+/**
+ * 언어 설정 상태 표시
+ */
+async function showLanguageStatus() {
+    try {
+        const status = await getLanguageStatus();
+        const currentLang = status.effectiveLanguage;
+        
+        console.log(chalk.blue.bold(`\n${getCliMessage('LANGUAGE_STATUS_TITLE', currentLang)}`));
+        console.log(chalk.gray('─'.repeat(50)));
+        
+        console.log(chalk.white(`${getCliMessage('DETECTED_LANGUAGE', currentLang)}: `) + 
+                   chalk.green(status.detectedLanguage));
+        
+        console.log(chalk.white(`${getCliMessage('CONFIGURED_LANGUAGE', currentLang)}: `) + 
+                   (status.configuredLanguage ? chalk.green(status.configuredLanguage) : 
+                    chalk.gray(getCliMessage('NOT_SET', currentLang))));
+        
+        console.log(chalk.white(`${getCliMessage('EFFECTIVE_LANGUAGE', currentLang)}: `) + 
+                   chalk.cyan.bold(status.effectiveLanguage));
+        
+        console.log(chalk.white(`${getCliMessage('AUTO_DETECT', currentLang)}: `) + 
+                   (status.autoDetect ? 
+                    chalk.green(getCliMessage('ENABLED', currentLang)) : 
+                    chalk.yellow(getCliMessage('DISABLED', currentLang))));
+        
+        console.log(chalk.white(`${getCliMessage('FALLBACK_LANGUAGE', currentLang)}: `) + 
+                   chalk.gray(status.fallbackLanguage));
+        
+        console.log(chalk.white(`${getCliMessage('SUPPORTED_LANGUAGES', currentLang)}: `) + 
+                   chalk.gray(status.supportedLanguages.join(', ')));
+        
+        console.log(chalk.white(`${getCliMessage('CONFIG_PATH', currentLang)}: `) + 
+                   chalk.gray(status.configPath));
+        
+        if (status.error) {
+            console.log(chalk.red('\n⚠️  Error: ' + status.error));
+        }
+        
+        console.log(chalk.gray('─'.repeat(50)));
+        
+    } catch (error) {
+        console.error(chalk.red('Error showing language status:', error.message));
+    }
+}
+
+/**
+ * 언어 설정 변경
+ */
+async function setLanguage(language = null, options = {}) {
+    try {
+        let targetLanguage = language;
+        let autoDetect = options.autoDetect;
+        
+        // 언어가 지정되지 않은 경우 사용자에게 선택 요청
+        if (!targetLanguage) {
+            const currentStatus = await getLanguageStatus();
+            const currentLang = currentStatus.effectiveLanguage;
+            
+            const languageResponse = await prompts({
+                type: 'select',
+                name: 'language',
+                message: getCliMessage('SELECT_LANGUAGE', currentLang),
+                choices: SUPPORTED_LANGUAGES.map(lang => ({
+                    title: lang === 'ko' ? '한국어 (Korean)' : 'English',
+                    value: lang
+                }))
+            });
+            
+            if (!languageResponse.language) {
+                console.log(chalk.yellow(getCliMessage('OPERATION_CANCELLED', currentLang)));
+                return;
+            }
+            
+            targetLanguage = languageResponse.language;
+            
+            // 자동 감지 설정이 지정되지 않은 경우 사용자에게 묻기
+            if (autoDetect === undefined) {
+                const autoDetectResponse = await prompts({
+                    type: 'confirm',
+                    name: 'autoDetect',
+                    message: getCliMessage('ENABLE_AUTO_DETECT', targetLanguage),
+                    initial: true
+                });
+                
+                autoDetect = autoDetectResponse.autoDetect;
+            }
+        }
+        
+        // 언어 전환 실행
+        const result = await switchLanguage(targetLanguage);
+        
+        if (result.success) {
+            console.log(chalk.green(`\n✅ ${getCliMessage('LANGUAGE_CHANGED', targetLanguage)}`));
+            console.log(chalk.gray(`   ${getCliMessage('PREVIOUS_LANGUAGE', targetLanguage)}: ${result.previousLanguage}`));
+            console.log(chalk.gray(`   ${getCliMessage('NEW_LANGUAGE', targetLanguage)}: ${result.newLanguage}`));
+            
+            // 자동 감지 설정 업데이트
+            if (autoDetect !== undefined) {
+                await saveUserLanguageConfig(targetLanguage, { autoDetect });
+                console.log(chalk.gray(`   ${getCliMessage('AUTO_DETECT', targetLanguage)}: ${autoDetect ? getCliMessage('ENABLED', targetLanguage) : getCliMessage('DISABLED', targetLanguage)}`));
+            }
+            
+        } else {
+            console.error(chalk.red('\n❌ ' + result.message));
+            if (result.error) {
+                console.error(chalk.gray('   Error: ' + result.error));
+            }
+        }
+        
+    } catch (error) {
+        console.error(chalk.red('Error setting language:', error.message));
+    }
+}
+
+/**
+ * 언어 설정 초기화
+ */
+async function resetLanguage() {
+    try {
+        const currentStatus = await getLanguageStatus();
+        const currentLang = currentStatus.effectiveLanguage;
+        
+        const confirmResponse = await prompts({
+            type: 'confirm',
+            name: 'confirm',
+            message: currentLang === 'ko' ? 
+                     '언어 설정을 초기화하시겠습니까? (자동 감지 모드로 돌아갑니다)' :
+                     'Reset language configuration? (Will return to auto-detection mode)',
+            initial: false
+        });
+        
+        if (!confirmResponse.confirm) {
+            console.log(chalk.yellow(getCliMessage('OPERATION_CANCELLED', currentLang)));
+            return;
+        }
+        
+        // 설정 파일 삭제 (자동 감지 모드로 복원)
+        const fs = await import('fs/promises');
+        const { LANGUAGE_CONFIG_PATH } = await import('./language-utils.js');
+        
+        try {
+            await fs.unlink(LANGUAGE_CONFIG_PATH);
+            console.log(chalk.green('\n✅ ' + (currentLang === 'ko' ? 
+                '언어 설정이 초기화되었습니다' : 
+                'Language configuration reset successfully')));
+            console.log(chalk.gray('   ' + (currentLang === 'ko' ? 
+                '이제 시스템 언어가 자동으로 감지됩니다' :
+                'System language will now be automatically detected')));
+        } catch (error) {
+            if (error.code === 'ENOENT') {
+                console.log(chalk.yellow('\n⚠️  ' + (currentLang === 'ko' ? 
+                    '설정 파일이 존재하지 않습니다' :
+                    'Configuration file does not exist')));
+            } else {
+                throw error;
+            }
+        }
+        
+    } catch (error) {
+        console.error(chalk.red('Error resetting language configuration:', error.message));
+    }
+}
+
+// CLI 명령어 정의
+program
+    .name('aiwf-lang')
+    .description('AIWF Language Management CLI / AIWF 언어 관리 CLI')
+    .version('1.0.0');
+
+program
+    .command('status')
+    .alias('s')
+    .description('Show current language configuration / 현재 언어 설정 표시')
+    .action(showLanguageStatus);
+
+program
+    .command('set [language]')
+    .alias('switch')
+    .description('Set or change language / 언어 설정 또는 변경')
+    .option('-a, --auto-detect [boolean]', 'Enable/disable auto detection / 자동 감지 활성화/비활성화')
+    .action(setLanguage);
+
+program
+    .command('reset')
+    .alias('r')
+    .description('Reset language configuration to auto-detection / 언어 설정을 자동 감지로 초기화')
+    .action(resetLanguage);
+
+// 기본 명령어 (인수 없이 실행 시)
+program
+    .action(async () => {
+        await showLanguageStatus();
+        console.log(chalk.blue('\n💡 사용 가능한 명령어 / Available commands:'));
+        console.log(chalk.gray('   aiwf-lang status    - 현재 설정 표시 / Show current configuration'));
+        console.log(chalk.gray('   aiwf-lang set       - 언어 설정 / Set language'));
+        console.log(chalk.gray('   aiwf-lang reset     - 설정 초기화 / Reset configuration'));
+    });
+
+// CLI 실행
+if (import.meta.url === `file://${process.argv[1]}`) {
+    program.parse(process.argv);
+}
+
+export default program;

package/language-utils.js

@@ -0,0 +1,330 @@
+#!/usr/bin/env node
+
+/**
+ * 언어 관리 유틸리티 모듈
+ * AIWF 프레임워크의 언어 감지, 설정 저장/복원, 라우팅을 담당합니다.
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+
+// 지원되는 언어 목록
+export const SUPPORTED_LANGUAGES = ['ko', 'en'];
+export const DEFAULT_LANGUAGE = 'en';
+export const LANGUAGE_CONFIG_PATH = '.aiwf/config/language.json';
+
+/**
+ * 언어 감지 알고리즘
+ * 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(getLocalizedMessage('LANGUAGE_NOT_SUPPORTED'));
+        }
+        
+        // 현재 언어 설정 로드
+        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/package.json

@@ -1,38 +1,51 @@
 {
     "name": "aiwf",
-    "version": "0.1.0",
-    "description": "AI Workflow Framework for Moonklabs",
+    "version": "0.3.1",
+    "description": "AI Workflow Framework for Claude Code with multi-language support (Korean/English)",
     "main": "index.js",
     "type": "module",
     "bin": {
-        "aiwf": "./index.js"
+        "aiwf": "./index.js",
+        "aiwf-lang": "./language-cli.js"
     },
     "scripts": {
-        "test": "echo \"Error: no test specified\" && exit 1"
+        "test": "node --experimental-vm-modules node_modules/.bin/jest",
+        "lang:status": "node language-cli.js status",
+        "lang:set": "node language-cli.js set",
+        "lang:reset": "node language-cli.js reset",
+        "validate:commands": "node scripts/validate-commands.js"
     },
     "keywords": [
-        "moonklabs",
+        "aiwf",
         "ai",
         "workflow",
-        "framework"
+        "framework",
+        "claude-code",
+        "multilingual",
+        "korean",
+        "english",
+        "project-management"
     ],
     "author": "moonklabs",
     "license": "MIT",
     "repository": {
         "type": "git",
-        "url": "git+https://github.com/moonklabs/aiwf.git"
+        "url": "git+https://github.com/aiwf/aiwf.git"
     },
     "bugs": {
-        "url": "https://github.com/moonklabs/aiwf/issues"
+        "url": "https://github.com/aiwf/aiwf/issues"
     },
-    "homepage": "https://github.com/moonklabs/aiwf#readme",
+    "homepage": "https://github.com/aiwf/aiwf#readme",
     "engines": {
         "node": ">=14.0.0"
     },
     "dependencies": {
-        "commander": "^11.1.0",
         "chalk": "^5.3.0",
+        "commander": "^11.1.0",
         "ora": "^8.0.1",
         "prompts": "^2.4.2"
+    },
+    "devDependencies": {
+        "jest": "^30.0.3"
     }
 }