aiwf 0.3.2 → 0.3.4

package/src/utils/git-integration.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+
+import { promises as fs } from 'fs';
+import path from 'path';
+import { exec, execSync } from 'child_process';
+import { promisify } from 'util';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const execAsync = promisify(exec);
+
+// AIWF 경로 설정
+const AIWF_ROOT = path.join(process.cwd(), '.aiwf');
+const FEATURE_LEDGERS_PATH = path.join(AIWF_ROOT, '06_FEATURE_LEDGERS');
+const ACTIVE_PATH = path.join(FEATURE_LEDGERS_PATH, 'active');
+
+// 커밋 메시지에서 Feature ID를 추출하는 정규식 패턴들
+const FEATURE_ID_PATTERNS = [
+    /FL\d{3}(?!\d)/,                    // FL001 (not followed by digit)
+    /\[FL\d{3}\]/,                      // [FL001]
+    /\(FL\d{3}\)/,                      // (FL001)
+    /(feat|fix|docs|style|refactor|test|chore)\(FL\d{3}\)/,  // feat(FL001)
+    /FL\d{3}:/,                         // FL001:
+    /#FL\d{3}/,                         // #FL001
+    /relates to FL\d{3}/i,              // relates to FL001
+];
+
+// Feature ID 추출 함수
+function extractFeatureId(text) {
+    for (const pattern of FEATURE_ID_PATTERNS) {
+        const match = text.match(pattern);
+        if (match) {
+            // 순수 Feature ID만 추출 (FL###)
+            const idMatch = match[0].match(/FL\d{3}/);
+            if (idMatch) {
+                return idMatch[0];
+            }
+        }
+    }
+    return null;
+}
+
+// Feature 파일 경로 가져오기
+async function getFeaturePath(featureId) {
+    // active 폴더에서 먼저 확인
+    const activePath = path.join(ACTIVE_PATH, `${featureId}_*.md`);
+    try {
+        const files = await fs.readdir(ACTIVE_PATH);
+        const featureFile = files.find(file => file.startsWith(`${featureId}_`));
+        if (featureFile) {
+            return path.join(ACTIVE_PATH, featureFile);
+        }
+    } catch (error) {
+        // 폴더가 없거나 읽기 실패 시 계속 진행
+    }
+    
+    // completed, archived 폴더도 확인
+    const otherPaths = ['completed', 'archived'];
+    for (const folder of otherPaths) {
+        const folderPath = path.join(FEATURE_LEDGERS_PATH, folder);
+        try {
+            const files = await fs.readdir(folderPath);
+            const featureFile = files.find(file => file.startsWith(`${featureId}_`));
+            if (featureFile) {
+                return path.join(folderPath, featureFile);
+            }
+        } catch (error) {
+            // 폴더가 없거나 읽기 실패 시 계속 진행
+        }
+    }
+    
+    return null;
+}
+
+// Git 커밋 정보 가져오기
+async function getCommitInfo(commitHash) {
+    try {
+        const { stdout } = await execAsync(`git show --no-patch --format="%H|%h|%an|%ae|%ad|%s" ${commitHash}`);
+        const [hash, shortHash, author, email, date, message] = stdout.trim().split('|');
+        return {
+            hash,
+            shortHash,
+            author,
+            email,
+            date: new Date(date).toISOString(),
+            message
+        };
+    } catch (error) {
+        console.error(`Error getting commit info for ${commitHash}:`, error.message);
+        return null;
+    }
+}
+
+// YAML frontmatter 파싱
+function parseYamlFrontmatter(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!match) return null;
+    
+    const yaml = match[1];
+    const metadata = {};
+    
+    // 간단한 YAML 파싱 (복잡한 구조는 제외)
+    yaml.split('\n').forEach(line => {
+        const keyValue = line.match(/^(\w+):\s*(.*)$/);
+        if (keyValue) {
+            const [_, key, value] = keyValue;
+            metadata[key] = value.trim();
+        }
+    });
+    
+    return metadata;
+}
+
+// YAML frontmatter 업데이트
+function updateYamlFrontmatter(content, metadata) {
+    const existingMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    
+    let yamlLines = [];
+    Object.entries(metadata).forEach(([key, value]) => {
+        if (value !== undefined && value !== null) {
+            yamlLines.push(`${key}: ${value}`);
+        }
+    });
+    
+    const newYaml = `---\n${yamlLines.join('\n')}\n---`;
+    
+    if (existingMatch) {
+        return content.replace(/^---\n[\s\S]*?\n---/, newYaml);
+    } else {
+        return `${newYaml}\n\n${content}`;
+    }
+}
+
+// Git 로그에서 Feature 관련 커밋 가져오기
+async function getFeatureCommits(featureId, since = null) {
+    try {
+        let gitCommand = `git log --grep="${featureId}" --format="%H|%h|%an|%ad|%s"`;
+        if (since) {
+            gitCommand += ` --since="${since}"`;
+        }
+        
+        const { stdout } = await execAsync(gitCommand);
+        if (!stdout.trim()) return [];
+        
+        const commits = stdout.trim().split('\n').map(line => {
+            const [hash, shortHash, author, date, message] = line.split('|');
+            return {
+                hash,
+                shortHash,
+                author,
+                date: new Date(date).toISOString(),
+                message
+            };
+        });
+        
+        return commits;
+    } catch (error) {
+        console.error(`Error getting commits for ${featureId}:`, error.message);
+        return [];
+    }
+}
+
+export {
+    extractFeatureId,
+    getFeaturePath,
+    getCommitInfo,
+    parseYamlFrontmatter,
+    updateYamlFrontmatter,
+    getFeatureCommits,
+    AIWF_ROOT,
+    FEATURE_LEDGERS_PATH,
+    ACTIVE_PATH
+};

package/{language-utils.js → src/utils/language-utils.js}

@@ -7,11 +7,12 @@
 
 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 = '.aiwf/config/language.json';
+export const LANGUAGE_CONFIG_PATH = FILES.LANGUAGE_CONFIG;
 
 /**
  * 언어 감지 알고리즘

package/src/utils/messages.js

@@ -0,0 +1,136 @@
+/**
+ * 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: '업데이트 (명령어와 문서만 업데이트하고 작업 내용은 보존)',
+    skipOption: '설치 건너뛰기',
+    cancelOption: '취소',
+    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}개 파일이 복원되었습니다'
+  },
+  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)',
+    skipOption: 'Skip installation',
+    cancelOption: 'Cancel',
+    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'
+  }
+};
+
+/**
+ * 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

@@ -0,0 +1,130 @@
+/**
+ * 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'),
+  ARCHITECTURE_DECISIONS: path.join(BASE_DIRS.AIWF, '05_ARCHITECTURE_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'),
+  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')
+  }
+};
+
+// Temporary directories
+export const TEMP_DIRS = {
+  RULES_GLOBAL: path.join(AIWF_DIRS.ROOT, '_tmp_rules_global'),
+  RULES_MANUAL: path.join(AIWF_DIRS.ROOT, '_tmp_rules_manual')
+};
+
+// 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.ARCHITECTURE_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;
+}
+
+// Get backup directory name with timestamp
+export function getBackupDirName() {
+  const now = new Date();
+  const pad = n => n.toString().padStart(2, '0');
+  const y = now.getFullYear();
+  const m = pad(now.getMonth() + 1);
+  const d = pad(now.getDate());
+  const h = pad(now.getHours());
+  const min = pad(now.getMinutes());
+  const s = pad(now.getSeconds());
+  return path.join(AIWF_DIRS.ROOT, `backup_${y}${m}${d}_${h}${min}${s}`);
+}
+
+// Export all for convenience
+export default {
+  BASE_DIRS,
+  AIWF_DIRS,
+  TOOL_DIRS,
+  FILES,
+  TEMP_DIRS,
+  USER_CACHE_DIR,
+  getAllAiwfDirectories,
+  getAllClaudeMdFiles,
+  getToolDirectory,
+  getBackupDirName
+};

package/tests/application.test.js

@@ -13,7 +13,7 @@ const __dirname = path.dirname(__filename);
 // 애플리케이션 실행 헬퍼
 async function runApp(args = [], timeout = 10000) {
   return new Promise((resolve, reject) => {
-    const appPath = path.join(__dirname, '..', 'index.js');
+    const appPath = path.join(__dirname, '..', 'src', 'cli', 'index.js');
     const child = spawn('node', [appPath, ...args], {
       stdio: 'pipe',
       timeout: timeout
@@ -70,7 +70,7 @@ describe('AIWF 애플리케이션 테스트', () => {
 describe('Language CLI 테스트', () => {
   async function runLanguageCli(args = [], timeout = 5000) {
     return new Promise((resolve, reject) => {
-      const cliPath = path.join(__dirname, '..', 'language-cli.js');
+      const cliPath = path.join(__dirname, '..', 'src', 'cli', 'language-cli.js');
       const child = spawn('node', [cliPath, ...args], {
         stdio: 'pipe',
         timeout: timeout

package/tests/installer.test.js

@@ -30,7 +30,7 @@ describe('AIWF 인스톨러 기능', () => {
   });
 
   test('버전 명령어가 올바르게 작동한다', () => {
-    const result = execSync('node index.js --version', { 
+    const result = execSync('node src/cli/index.js --version', { 
       cwd: path.join(__dirname, '..'),
       encoding: 'utf8',
       timeout: 5000
@@ -39,7 +39,7 @@ describe('AIWF 인스톨러 기능', () => {
   });
 
   test('도움말 명령어가 올바르게 작동한다', () => {
-    const result = execSync('node index.js --help', { 
+    const result = execSync('node src/cli/index.js --help', { 
       cwd: path.join(__dirname, '..'),
       encoding: 'utf8',
       timeout: 5000

package/tests/integration/ai-persona-system.test.js

@@ -2,10 +2,10 @@
  * AI Persona System Integration Tests
  */
 
-import { AIPersonaManager } from '../../lib/ai-persona-manager.js';
-import { ContextEngine } from '../../lib/context-engine.js';
-import { MetricsCollector } from '../../lib/metrics-collector.js';
-import { TaskAnalyzer } from '../../lib/task-analyzer.js';
+import { AIPersonaManager } from '../../src/lib/ai-persona-manager.js';
+import { ContextEngine } from '../../src/lib/context-engine.js';
+import { MetricsCollector } from '../../src/lib/metrics-collector.js';
+import { TaskAnalyzer } from '../../src/lib/task-analyzer.js';
 import fs from 'fs/promises';
 import path from 'path';
 import { fileURLToPath } from 'url';

package/tests/integration/test-persona-system/docs/README.md

@@ -0,0 +1 @@
+# Project

package/tests/integration/test-persona-system/package.json

@@ -0,0 +1 @@
+{"name":"test-project"}

package/tests/integration/test-persona-system/src/auth.js

@@ -0,0 +1 @@
+function login() {}

package/tests/integration/test-persona-system/src/index.js

@@ -0,0 +1 @@
+console.log("Hello");

package/tests/integration/test-persona-system/test/test.js

@@ -0,0 +1 @@
+describe("test", () => {});

package/tests/language-utils.test.js

@@ -18,7 +18,7 @@ import {
     SUPPORTED_LANGUAGES,
     DEFAULT_LANGUAGE,
     LANGUAGE_CONFIG_PATH
-} from '../language-utils.js';
+} from '../src/utils/language-utils.js';
 
 // 테스트용 임시 디렉토리
 const TEST_DIR = '.aiwf-test';

package/tests/temp_invalid_json/invalid.json

@@ -0,0 +1 @@
+{ invalid json }

package/tests/unit/ai-persona-manager.test.js

@@ -3,17 +3,17 @@
  */
 
 import { jest } from '@jest/globals';
-import { AIPersonaManager } from '../../lib/ai-persona-manager.js';
-import { ContextEngine } from '../../lib/context-engine.js';
-import { MetricsCollector } from '../../lib/metrics-collector.js';
-import { TaskAnalyzer } from '../../lib/task-analyzer.js';
+import { AIPersonaManager } from '../../src/lib/ai-persona-manager.js';
+import { ContextEngine } from '../../src/lib/context-engine.js';
+import { MetricsCollector } from '../../src/lib/metrics-collector.js';
+import { TaskAnalyzer } from '../../src/lib/task-analyzer.js';
 import fs from 'fs/promises';
 import path from 'path';
 
 // Mock dependencies
-jest.mock('../../lib/context-engine.js');
-jest.mock('../../lib/metrics-collector.js');
-jest.mock('../../lib/task-analyzer.js');
+jest.mock('../../src/lib/context-engine.js');
+jest.mock('../../src/lib/metrics-collector.js');
+jest.mock('../../src/lib/task-analyzer.js');
 jest.mock('fs/promises');
 
 describe('AIPersonaManager', () => {

package/.aiwf/05_DOCUMENTATION/performance-report.md

@@ -1,33 +0,0 @@
-# 성능 보고서
-
-## 개요
-이 문서는 AIWF 프레임워크의 성능 벤치마크 결과를 요약합니다.
-
-## 토큰 사용량 분석
-### 기준선
-- **이전 버전**: 1,000 토큰
-- **현재 버전**: 500 토큰
-- **절감률**: 50%
-
-### 성능 개선 사항
-1. **컨텍스트 압축**: 40% 토큰 절약
-2. **불필요한 정보 제거**: 30% 토큰 절약
-3. **효율적인 구조화**: 20% 토큰 절약
-
-## 응답 시간 분석
-- **평균 응답 시간**: 2.3초
-- **최대 응답 시간**: 5.1초
-- **최소 응답 시간**: 0.8초
-
-## 메모리 사용량
-- **평균 메모리 사용량**: 256MB
-- **최대 메모리 사용량**: 512MB
-- **메모리 최적화율**: 35%
-
-## 결론
-AIWF 프레임워크는 토큰 사용량을 50% 절감하여 성능 목표를 달성했습니다.
-
-## 권장사항
-1. 지속적인 모니터링 필요
-2. 추가 최적화 기회 탐색
-3. 성능 회귀 방지 체계 구축

package/.aiwf/test-cache/86c7f9e80251abb8bedd58953ab0d1779e46b4f43ea33b63bffdb778106373b0.json

@@ -1,6 +0,0 @@
-{
-  "data": {
-    "integrated": true
-  },
-  "timestamp": 1752000073988
-}

package/.aiwf/test-cache/9e252a90b80fce0585d7ed0646e7a9b4343e109f661f42a3ae678ba1ec5e22c7.json

@@ -1,7 +0,0 @@
-{
-  "data": {
-    "message": "test data",
-    "timestamp": 1752000073907
-  },
-  "timestamp": 1752000073908
-}