aiwf 0.3.8 → 0.3.13

package/claude-code/aiwf/ko/commands/compress-context.js

@@ -1,389 +0,0 @@
-#!/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/claude-code/aiwf/ko/commands/evaluate.js

@@ -1,246 +0,0 @@
-#!/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;