aiwf 0.3.6 → 0.3.8

package/src/lib/resources/commands/compress-context.js

@@ -0,0 +1,389 @@
+#!/usr/bin/env node
+
+import { ContextCompressor } from '../utils/context-compressor.js';
+import { PersonaAwareCompressor } from '../utils/persona-aware-compressor.js';
+import { getBackgroundMonitor } from '../utils/background-monitor.js';
+import { TokenCounter } from '../utils/token-counter.js';
+import { CompressionMetrics } from '../utils/compression-metrics.js';
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * compress-context 명령어 실행
+ */
+export async function executeCompressContext(args = []) {
+  const spinner = ora('Context 압축 준비 중...').start();
+  
+  try {
+    // 파라미터 파싱
+    const { mode, targetPath, usePersona } = parseArguments(args);
+    
+    spinner.text = '압축 대상 분석 중...';
+    
+    // 대상 경로 결정
+    const resolvedPath = await resolveTargetPath(targetPath);
+    const files = await collectMarkdownFiles(resolvedPath);
+    
+    if (files.length === 0) {
+      spinner.fail('압축할 마크다운 파일이 없습니다.');
+      return;
+    }
+    
+    // 압축 전 통계
+    spinner.text = '원본 토큰 수 계산 중...';
+    const beforeStats = await calculateStats(files);
+    
+    // 압축 시작
+    console.log('');
+    console.log(chalk.cyan('🗜️  Context 압축 시작'));
+    console.log(chalk.gray('━'.repeat(50)));
+    console.log(`압축 모드: ${chalk.yellow(mode)}`);
+    console.log(`대상: ${chalk.yellow(resolvedPath)}`);
+    console.log(`페르소나 연동: ${chalk.yellow(usePersona ? '활성화' : '비활성화')}`);
+    console.log('');
+    
+    console.log(chalk.cyan('📊 압축 전 통계:'));
+    console.log(`- 총 파일 수: ${files.length}`);
+    console.log(`- 원본 토큰: ${chalk.red(beforeStats.totalTokens.toLocaleString())}`);
+    console.log(`- 원본 크기: ${(beforeStats.totalSize / 1024).toFixed(1)} KB`);
+    console.log('');
+    
+    spinner.text = '압축 진행 중...';
+    
+    // 압축 수행
+    const compressor = usePersona 
+      ? new PersonaAwareCompressor(mode)
+      : new ContextCompressor(mode);
+    const compressionResults = [];
+    const startTime = Date.now();
+    
+    console.log(chalk.cyan('⚙️  압축 진행 중...'));
+    
+    for (const file of files) {
+      const fileName = path.basename(file);
+      const content = await fs.readFile(file, 'utf8');
+      
+      const result = await compressor.compress(content, {
+        strategy: mode,
+        preserveStructure: true,
+        enableSummarization: mode === 'aggressive',
+        enableNormalization: true,
+        enableFiltering: mode !== 'minimal'
+      });
+      
+      if (result.success) {
+        const savedTokens = result.originalTokens - result.compressedTokens;
+        const ratio = result.compressionRatio.toFixed(1);
+        
+        console.log(chalk.green(`✓ ${fileName} (${result.originalTokens.toLocaleString()} → ${result.compressedTokens.toLocaleString()} 토큰, -${ratio}%)`));
+        
+        compressionResults.push({
+          filePath: file,
+          fileName,
+          ...result
+        });
+      } else {
+        console.log(chalk.red(`✗ ${fileName} (압축 실패: ${result.error})`));
+      }
+    }
+    
+    const processingTime = Date.now() - startTime;
+    
+    // 압축 후 통계
+    const afterStats = calculateCompressedStats(compressionResults);
+    const totalSaved = beforeStats.totalTokens - afterStats.totalTokens;
+    const overallRatio = ((totalSaved / beforeStats.totalTokens) * 100).toFixed(1);
+    
+    // 압축된 파일 저장
+    spinner.text = '압축된 파일 저장 중...';
+    const outputDir = await saveCompressedFiles(compressionResults, resolvedPath);
+    
+    // 압축 보고서 생성
+    await generateReport(compressionResults, {
+      mode,
+      targetPath: resolvedPath,
+      outputDir,
+      beforeStats,
+      afterStats,
+      processingTime
+    });
+    
+    spinner.stop();
+    
+    // 결과 출력
+    console.log('');
+    console.log(chalk.cyan('📊 압축 후 통계:'));
+    console.log(`- 압축된 토큰: ${chalk.green(afterStats.totalTokens.toLocaleString())}`);
+    console.log(`- 절약된 토큰: ${chalk.green(totalSaved.toLocaleString())}`);
+    console.log(`- 토큰 절약률: ${chalk.green(overallRatio + '%')}`);
+    console.log(`- 압축 시간: ${(processingTime / 1000).toFixed(1)}초`);
+    
+    // 평균 품질 점수 계산
+    const avgQuality = compressionResults.reduce((sum, r) => {
+      return sum + (r.metadata?.validation?.qualityScore || 0);
+    }, 0) / compressionResults.length;
+    
+    console.log(`- 품질 점수: ${chalk.green(avgQuality.toFixed(0) + '/100')}`);
+    
+    // 페르소나 정보 출력
+    if (usePersona && compressor.currentPersona) {
+      console.log(`- 활성 페르소나: ${chalk.cyan(compressor.currentPersona)}`);
+    }
+    
+    console.log('');
+    
+    console.log(chalk.green('✅ 압축 완료!'));
+    console.log(`압축된 파일 위치: ${chalk.yellow(outputDir)}`);
+    
+    // 페르소나 인식 압축인 경우 백그라운드 품질 체크
+    if (usePersona && compressor.currentPersona) {
+      const monitor = getBackgroundMonitor();
+      
+      // 압축된 내용의 샘플로 품질 체크 (비차단)
+      const sampleResult = compressionResults[0];
+      if (sampleResult) {
+        monitor.monitorResponse(
+          sampleResult.compressed.substring(0, 1000), // 샘플만
+          compressor.currentPersona,
+          { silent: false }
+        ).then(feedback => {
+          if (feedback && feedback.feedback) {
+            console.log('');
+            console.log(feedback.feedback);
+          }
+        }).catch(() => {}); // 에러 무시
+      }
+    }
+    
+    // 목표 달성 여부 확인
+    const targetRange = getTargetRange(mode);
+    if (parseFloat(overallRatio) < targetRange.min) {
+      console.log('');
+      console.log(chalk.yellow(`⚠️  경고: 압축률이 목표 범위(${targetRange.min}-${targetRange.max}%)에 미달했습니다.`));
+      console.log('더 높은 압축률이 필요하면 aggressive 모드를 시도해보세요.');
+    }
+    
+    // 리소스 정리
+    compressor.cleanup();
+    
+  } catch (error) {
+    spinner.fail(`압축 실패: ${error.message}`);
+    console.error(error);
+  }
+}
+
+/**
+ * 명령어 인자를 파싱합니다
+ * @param {Array<string>} args - 인자 배열
+ * @returns {Object} 파싱된 옵션
+ */
+function parseArguments(args) {
+  let mode = 'balanced';
+  let targetPath = null;
+  let usePersona = false;
+  
+  for (const arg of args) {
+    if (['aggressive', 'balanced', 'minimal'].includes(arg)) {
+      mode = arg;
+    } else if (arg === '--persona' || arg === '-p') {
+      usePersona = true;
+    } else if (arg && !arg.startsWith('-')) {
+      targetPath = arg;
+    }
+  }
+  
+  return { mode, targetPath, usePersona };
+}
+
+/**
+ * 대상 경로를 결정합니다
+ * @param {string} targetPath - 사용자 지정 경로
+ * @returns {string} 결정된 경로
+ */
+async function resolveTargetPath(targetPath) {
+  if (targetPath) {
+    // 절대 경로가 아니면 현재 디렉토리 기준으로 변환
+    if (!path.isAbsolute(targetPath)) {
+      targetPath = path.join(process.cwd(), targetPath);
+    }
+    return targetPath;
+  }
+  
+  // 기본값: 프로젝트의 .aiwf 디렉토리
+  const aiwfPath = path.join(process.cwd(), '.aiwf');
+  try {
+    await fs.access(aiwfPath);
+    return aiwfPath;
+  } catch {
+    // .aiwf가 없으면 현재 디렉토리
+    return process.cwd();
+  }
+}
+
+/**
+ * 마크다운 파일들을 수집합니다
+ * @param {string} targetPath - 대상 경로
+ * @returns {Array<string>} 파일 경로 배열
+ */
+async function collectMarkdownFiles(targetPath) {
+  const files = [];
+  
+  try {
+    const stats = await fs.stat(targetPath);
+    
+    if (stats.isFile() && targetPath.endsWith('.md')) {
+      files.push(targetPath);
+    } else if (stats.isDirectory()) {
+      await collectFromDirectory(targetPath, files);
+    }
+  } catch (error) {
+    console.error(`경로 접근 오류: ${targetPath}`);
+  }
+  
+  return files;
+}
+
+/**
+ * 디렉토리에서 마크다운 파일을 재귀적으로 수집합니다
+ * @param {string} dirPath - 디렉토리 경로
+ * @param {Array<string>} files - 파일 배열
+ */
+async function collectFromDirectory(dirPath, files) {
+  const entries = await fs.readdir(dirPath, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry.name);
+    
+    if (entry.isDirectory() && !entry.name.startsWith('.')) {
+      await collectFromDirectory(fullPath, files);
+    } else if (entry.isFile() && entry.name.endsWith('.md')) {
+      files.push(fullPath);
+    }
+  }
+}
+
+/**
+ * 파일 통계를 계산합니다
+ * @param {Array<string>} files - 파일 경로 배열
+ * @returns {Object} 통계 정보
+ */
+async function calculateStats(files) {
+  const tokenCounter = new TokenCounter();
+  let totalTokens = 0;
+  let totalSize = 0;
+  
+  for (const file of files) {
+    const content = await fs.readFile(file, 'utf8');
+    totalTokens += tokenCounter.countTokens(content);
+    totalSize += Buffer.byteLength(content, 'utf8');
+  }
+  
+  tokenCounter.cleanup();
+  
+  return { totalTokens, totalSize };
+}
+
+/**
+ * 압축된 통계를 계산합니다
+ * @param {Array<Object>} results - 압축 결과 배열
+ * @returns {Object} 통계 정보
+ */
+function calculateCompressedStats(results) {
+  const totalTokens = results.reduce((sum, r) => sum + r.compressedTokens, 0);
+  const totalSize = results.reduce((sum, r) => sum + Buffer.byteLength(r.compressed, 'utf8'), 0);
+  
+  return { totalTokens, totalSize };
+}
+
+/**
+ * 압축된 파일들을 저장합니다
+ * @param {Array<Object>} results - 압축 결과 배열
+ * @param {string} targetPath - 원본 경로
+ * @returns {string} 출력 디렉토리
+ */
+async function saveCompressedFiles(results, targetPath) {
+  const timestamp = new Date().toISOString().slice(0, 19).replace(/:/g, '-');
+  const outputDir = path.join(path.dirname(targetPath), `.aiwf_compressed`, timestamp);
+  
+  await fs.mkdir(outputDir, { recursive: true });
+  
+  for (const result of results) {
+    const outputPath = path.join(outputDir, result.fileName);
+    await fs.writeFile(outputPath, result.compressed);
+  }
+  
+  return outputDir;
+}
+
+/**
+ * 압축 보고서를 생성합니다
+ * @param {Array<Object>} results - 압축 결과 배열
+ * @param {Object} stats - 통계 정보
+ */
+async function generateReport(results, stats) {
+  const report = [];
+  
+  report.push('# Context 압축 보고서');
+  report.push('');
+  report.push(`**생성 시간**: ${new Date().toISOString()}`);
+  report.push(`**압축 모드**: ${stats.mode}`);
+  report.push(`**대상 경로**: ${stats.targetPath}`);
+  report.push(`**출력 경로**: ${stats.outputDir}`);
+  report.push('');
+  
+  report.push('## 전체 통계');
+  report.push(`- **파일 수**: ${results.length}`);
+  report.push(`- **원본 토큰**: ${stats.beforeStats.totalTokens.toLocaleString()}`);
+  report.push(`- **압축 토큰**: ${stats.afterStats.totalTokens.toLocaleString()}`);
+  report.push(`- **절약 토큰**: ${(stats.beforeStats.totalTokens - stats.afterStats.totalTokens).toLocaleString()}`);
+  report.push(`- **전체 압축률**: ${((stats.beforeStats.totalTokens - stats.afterStats.totalTokens) / stats.beforeStats.totalTokens * 100).toFixed(1)}%`);
+  report.push(`- **처리 시간**: ${(stats.processingTime / 1000).toFixed(1)}초`);
+  report.push('');
+  
+  report.push('## 파일별 상세');
+  report.push('');
+  report.push('| 파일명 | 원본 토큰 | 압축 토큰 | 압축률 | 품질 점수 |');
+  report.push('|--------|-----------|-----------|--------|-----------|');
+  
+  for (const result of results) {
+    const qualityScore = result.metadata?.validation?.qualityScore || 0;
+    report.push(
+      `| ${result.fileName} | ${result.originalTokens.toLocaleString()} | ` +
+      `${result.compressedTokens.toLocaleString()} | ${result.compressionRatio}% | ` +
+      `${qualityScore}/100 |`
+    );
+  }
+  
+  const reportPath = path.join(stats.outputDir, 'compression-report.md');
+  await fs.writeFile(reportPath, report.join('\n'));
+}
+
+/**
+ * 압축 모드별 목표 범위를 반환합니다
+ * @param {string} mode - 압축 모드
+ * @returns {Object} 목표 범위
+ */
+function getTargetRange(mode) {
+  const ranges = {
+    aggressive: { min: 50, max: 70 },
+    balanced: { min: 30, max: 50 },
+    minimal: { min: 10, max: 30 }
+  };
+  
+  return ranges[mode] || { min: 0, max: 100 };
+}
+
+// CLI로 직접 실행하는 경우
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const args = process.argv.slice(2);
+  executeCompressContext(args);
+}
+
+export default executeCompressContext;

package/src/lib/resources/commands/evaluate.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+
+/**
+ * 경량화된 평가 명령어
+ * 선택적으로 사용할 수 있는 간단한 평가 도구
+ */
+
+import { SimplifiedEvaluator } from '../utils/simplified-evaluator.js';
+import { getBackgroundMonitor } from '../utils/background-monitor.js';
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * evaluate 명령어 실행
+ */
+export async function executeEvaluate(args = []) {
+  const option = args[0];
+  
+  try {
+    switch (option) {
+      case '--detailed':
+      case '-d':
+        return await detailedEvaluation();
+        
+      case '--history':
+      case '-h':
+        return await showHistory();
+        
+      case '--stats':
+      case '-s':
+        return await showStats();
+        
+      default:
+        return await quickEvaluation();
+    }
+  } catch (error) {
+    console.error(chalk.red('오류:'), error.message);
+  }
+}
+
+/**
+ * 빠른 평가 (기본)
+ */
+async function quickEvaluation() {
+  console.log(chalk.cyan('🔍 최근 응답 평가'));
+  console.log(chalk.gray('━'.repeat(50)));
+  
+  // 현재 페르소나 확인
+  const currentPersona = await getCurrentPersona();
+  if (!currentPersona) {
+    console.log(chalk.yellow('활성화된 페르소나가 없습니다.'));
+    console.log('페르소나를 먼저 활성화하세요: aiwf persona [architect|security|frontend|backend|data_analyst]');
+    return;
+  }
+  
+  console.log(`현재 페르소나: ${chalk.yellow(currentPersona)}`);
+  
+  // 최근 통계 표시
+  const monitor = getBackgroundMonitor();
+  const stats = monitor.getRecentStats(currentPersona);
+  
+  if (stats.message) {
+    console.log(stats.message);
+    return;
+  }
+  
+  console.log(`평균 점수: ${chalk.green(stats.averageScore)}`);
+  console.log(`평가 횟수: ${stats.totalEvaluations}`);
+  console.log(`추세: ${getTrendEmoji(stats.trend)} ${getKoreanTrend(stats.trend)}`);
+  
+  // 간단한 팁
+  if (parseFloat(stats.averageScore) < 0.6) {
+    console.log('');
+    console.log(chalk.yellow('💡 팁: 페르소나 특성을 더 활용해보세요!'));
+  } else if (parseFloat(stats.averageScore) > 0.8) {
+    console.log('');
+    console.log(chalk.green('🎉 훌륭해요! 페르소나를 잘 활용하고 있습니다.'));
+  }
+}
+
+/**
+ * 상세 평가
+ */
+async function detailedEvaluation() {
+  console.log(chalk.cyan('📊 상세 평가 분석'));
+  console.log(chalk.gray('━'.repeat(50)));
+  
+  const monitor = getBackgroundMonitor();
+  const stats = monitor.getRecentStats();
+  
+  if (stats.message) {
+    console.log(stats.message);
+    return;
+  }
+  
+  console.log(chalk.white('전체 통계:'));
+  console.log(`- 총 평가: ${stats.totalEvaluations}회`);
+  console.log(`- 평균 점수: ${stats.averageScore}`);
+  console.log(`- 추세: ${getTrendEmoji(stats.trend)} ${getKoreanTrend(stats.trend)}`);
+  
+  console.log('');
+  console.log(chalk.white('페르소나별 성과:'));
+  
+  Object.entries(stats.personaStats).forEach(([persona, data]) => {
+    const score = parseFloat(data.avgScore);
+    const scoreColor = score >= 0.8 ? 'green' : score >= 0.6 ? 'yellow' : 'red';
+    
+    console.log(`- ${getKoreanPersonaName(persona)}: ${chalk[scoreColor](data.avgScore)} (${data.count}회)`);
+  });
+  
+  // 개선 제안
+  console.log('');
+  console.log(chalk.white('개선 제안:'));
+  
+  Object.entries(stats.personaStats).forEach(([persona, data]) => {
+    if (parseFloat(data.avgScore) < 0.6) {
+      const evaluator = new SimplifiedEvaluator();
+      const feedback = evaluator.getGentleFeedback(persona, parseFloat(data.avgScore));
+      if (feedback) {
+        console.log(feedback);
+      }
+    }
+  });
+}
+
+/**
+ * 평가 히스토리
+ */
+async function showHistory() {
+  console.log(chalk.cyan('📈 평가 히스토리'));
+  console.log(chalk.gray('━'.repeat(50)));
+  
+  const monitor = getBackgroundMonitor();
+  const history = monitor.recentEvaluations.slice(-10); // 최근 10개
+  
+  if (history.length === 0) {
+    console.log('평가 기록이 없습니다.');
+    return;
+  }
+  
+  history.forEach((eval, index) => {
+    const date = new Date(eval.timestamp);
+    const timeStr = `${date.getHours()}:${date.getMinutes().toString().padStart(2, '0')}`;
+    const scoreColor = eval.score >= 0.8 ? 'green' : eval.score >= 0.6 ? 'yellow' : 'red';
+    
+    console.log(`${timeStr} | ${getKoreanPersonaName(eval.persona)} | ${chalk[scoreColor](eval.score.toFixed(2))}`);
+  });
+}
+
+/**
+ * 주간 통계
+ */
+async function showStats() {
+  console.log(chalk.cyan('📊 주간 통계'));
+  console.log(chalk.gray('━'.repeat(50)));
+  
+  const monitor = getBackgroundMonitor();
+  const summary = monitor.getWeeklySummary();
+  
+  if (summary.message) {
+    console.log(summary.message);
+    return;
+  }
+  
+  console.log(`평가 횟수: ${summary.evaluationCount}회`);
+  console.log(`평균 점수: ${summary.averageScore}`);
+  console.log(`추세: ${getTrendEmoji(summary.trend)} ${getKoreanTrend(summary.trend)}`);
+  
+  if (summary.personaStats) {
+    console.log('');
+    console.log('페르소나별 활용도:');
+    
+    const sorted = Object.entries(summary.personaStats)
+      .sort((a, b) => b[1].count - a[1].count);
+    
+    sorted.forEach(([persona, data]) => {
+      const bar = '█'.repeat(Math.floor(data.count / 2));
+      console.log(`${getKoreanPersonaName(persona).padEnd(10)} ${bar} ${data.count}회`);
+    });
+  }
+}
+
+/**
+ * 현재 페르소나 가져오기
+ */
+async function getCurrentPersona() {
+  try {
+    const personaPath = path.join(process.cwd(), '.aiwf', 'current_persona.json');
+    const data = await fs.readFile(personaPath, 'utf8');
+    const personaData = JSON.parse(data);
+    return personaData.persona;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 페르소나 이름 한글화
+ */
+function getKoreanPersonaName(persona) {
+  const names = {
+    architect: '아키텍트',
+    security: '보안 전문가',
+    frontend: '프론트엔드',
+    backend: '백엔드',
+    data_analyst: '데이터 분석가'
+  };
+  return names[persona] || persona;
+}
+
+/**
+ * 추세 이모지
+ */
+function getTrendEmoji(trend) {
+  const emojis = {
+    improving: '📈',
+    declining: '📉',
+    stable: '➡️'
+  };
+  return emojis[trend] || '❓';
+}
+
+/**
+ * 추세 한글화
+ */
+function getKoreanTrend(trend) {
+  const trends = {
+    improving: '개선 중',
+    declining: '하락 중',
+    stable: '안정적'
+  };
+  return trends[trend] || trend;
+}
+
+// CLI로 직접 실행하는 경우
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const args = process.argv.slice(2);
+  executeEvaluate(args);
+}
+
+export default executeEvaluate;