aiwf 0.3.7 → 0.3.12

package/src/commands/evaluate.js

@@ -0,0 +1,459 @@
+#!/usr/bin/env node
+
+/**
+ * AIWF 평가 명령어
+ * AI 응답 품질 평가 및 개선
+ */
+
+import { ResourceLoader } from '../lib/resource-loader.js';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+
+class EvaluateCommand {
+  constructor() {
+    this.resourceLoader = new ResourceLoader();
+    this.evaluationPath = path.join(process.cwd(), '.aiwf', 'evaluations');
+  }
+
+  /**
+   * Evaluate 명령어 실행
+   */
+  async execute(args) {
+    const [subcommand, ...restArgs] = args;
+
+    switch (subcommand) {
+      case 'response':
+        await this.evaluateResponse(restArgs);
+        break;
+      case 'code':
+        await this.evaluateCode(restArgs);
+        break;
+      case 'persona':
+        await this.evaluatePersona(restArgs);
+        break;
+      case 'report':
+        await this.generateReport();
+        break;
+      case 'criteria':
+        await this.showCriteria();
+        break;
+      default:
+        this.showHelp();
+        break;
+    }
+  }
+
+  /**
+   * AI 응답 평가
+   */
+  async evaluateResponse(args) {
+    const [responsePath] = args;
+    
+    if (!responsePath) {
+      console.error(chalk.red('❌ 평가할 응답 파일 경로를 지정해주세요.'));
+      console.log(chalk.gray('사용법: aiwf evaluate response <파일경로>'));
+      return;
+    }
+
+    try {
+      // 평가자 모듈 로드
+      const evaluatorModule = await this.resourceLoader.loadUtil('simplified-evaluator.js');
+      const SimplifiedEvaluator = evaluatorModule.SimplifiedEvaluator || evaluatorModule.default;
+      
+      if (!SimplifiedEvaluator) {
+        throw new Error('SimplifiedEvaluator 모듈을 로드할 수 없습니다.');
+      }
+
+      const evaluator = new SimplifiedEvaluator();
+      
+      // 응답 내용 읽기
+      const content = await fs.readFile(responsePath, 'utf8');
+      
+      console.log(chalk.cyan('🔍 AI 응답 평가 중...'));
+      
+      // 평가 수행
+      const evaluation = await evaluator.evaluate(content, 'response');
+      
+      // 결과 표시
+      this.displayEvaluation(evaluation);
+      
+      // 평가 결과 저장
+      await this.saveEvaluation(evaluation, 'response', responsePath);
+      
+    } catch (error) {
+      console.error(chalk.red('❌ 응답 평가 중 오류가 발생했습니다:'), error.message);
+    }
+  }
+
+  /**
+   * 코드 품질 평가
+   */
+  async evaluateCode(args) {
+    const [codePath] = args;
+    
+    if (!codePath) {
+      console.error(chalk.red('❌ 평가할 코드 파일 경로를 지정해주세요.'));
+      console.log(chalk.gray('사용법: aiwf evaluate code <파일경로>'));
+      return;
+    }
+
+    try {
+      const evaluatorModule = await this.resourceLoader.loadUtil('simplified-evaluator.js');
+      const SimplifiedEvaluator = evaluatorModule.SimplifiedEvaluator || evaluatorModule.default;
+      
+      const evaluator = new SimplifiedEvaluator();
+      
+      // 코드 내용 읽기
+      const code = await fs.readFile(codePath, 'utf8');
+      const language = path.extname(codePath).slice(1) || 'javascript';
+      
+      console.log(chalk.cyan('🔍 코드 품질 평가 중...'));
+      
+      // 평가 수행
+      const evaluation = await evaluator.evaluateCode(code, language);
+      
+      // 결과 표시
+      this.displayCodeEvaluation(evaluation);
+      
+      // 평가 결과 저장
+      await this.saveEvaluation(evaluation, 'code', codePath);
+      
+    } catch (error) {
+      console.error(chalk.red('❌ 코드 평가 중 오류가 발생했습니다:'), error.message);
+    }
+  }
+
+  /**
+   * 페르소나 적합성 평가
+   */
+  async evaluatePersona(args) {
+    const [contentPath, personaName] = args;
+    
+    if (!contentPath || !personaName) {
+      console.error(chalk.red('❌ 콘텐츠 경로와 페르소나 이름을 지정해주세요.'));
+      console.log(chalk.gray('사용법: aiwf evaluate persona <파일경로> <페르소나명>'));
+      return;
+    }
+
+    try {
+      // 페르소나 인식 평가자 로드
+      const backgroundModule = await this.resourceLoader.loadUtil('background-monitor.js');
+      const BackgroundMonitor = backgroundModule.BackgroundMonitor || backgroundModule.default;
+      
+      const monitor = new BackgroundMonitor();
+      
+      // 콘텐츠 읽기
+      const content = await fs.readFile(contentPath, 'utf8');
+      
+      console.log(chalk.cyan(`🎭 페르소나 적합성 평가 중 (${personaName})...`));
+      
+      // 평가 수행
+      const result = await monitor.monitorResponse(content, personaName);
+      
+      // 결과 표시
+      this.displayPersonaEvaluation(result, personaName);
+      
+      // 평가 결과 저장
+      await this.saveEvaluation(result, 'persona', contentPath, { persona: personaName });
+      
+    } catch (error) {
+      console.error(chalk.red('❌ 페르소나 평가 중 오류가 발생했습니다:'), error.message);
+    }
+  }
+
+  /**
+   * 평가 리포트 생성
+   */
+  async generateReport() {
+    try {
+      const evaluations = await this.loadAllEvaluations();
+      
+      if (evaluations.length === 0) {
+        console.log(chalk.yellow('⚠️  저장된 평가 결과가 없습니다.'));
+        return;
+      }
+
+      console.log(chalk.cyan('📊 평가 리포트 생성 중...'));
+      
+      const report = this.createReport(evaluations);
+      const reportPath = path.join(this.evaluationPath, 'reports', `evaluation-report-${Date.now()}.md`);
+      
+      await fs.ensureDir(path.dirname(reportPath));
+      await fs.writeFile(reportPath, report);
+      
+      console.log(chalk.green(`✅ 리포트가 생성되었습니다: ${reportPath}`));
+      
+      // 요약 표시
+      const summary = this.createSummary(evaluations);
+      console.log(chalk.cyan('\n📈 평가 요약:'));
+      console.log(summary);
+      
+    } catch (error) {
+      console.error(chalk.red('❌ 리포트 생성 중 오류가 발생했습니다:'), error.message);
+    }
+  }
+
+  /**
+   * 평가 기준 표시
+   */
+  async showCriteria() {
+    try {
+      const criteria = await this.resourceLoader.loadJSON('personas', 'evaluation_criteria.json');
+      
+      console.log(chalk.cyan('📋 평가 기준'));
+      console.log(chalk.gray('-'.repeat(50)));
+      
+      // 응답 평가 기준
+      console.log(chalk.bold('\n응답 평가 기준:'));
+      Object.entries(criteria.response || {}).forEach(([key, desc]) => {
+        console.log(`  • ${chalk.yellow(key)}: ${desc}`);
+      });
+      
+      // 코드 평가 기준
+      console.log(chalk.bold('\n코드 평가 기준:'));
+      Object.entries(criteria.code || {}).forEach(([key, desc]) => {
+        console.log(`  • ${chalk.yellow(key)}: ${desc}`);
+      });
+      
+      // 페르소나 평가 기준
+      console.log(chalk.bold('\n페르소나 평가 기준:'));
+      Object.entries(criteria.persona || {}).forEach(([key, desc]) => {
+        console.log(`  • ${chalk.yellow(key)}: ${desc}`);
+      });
+      
+    } catch (error) {
+      // 기본 기준 표시
+      console.log(chalk.cyan('📋 평가 기준'));
+      console.log(chalk.gray('-'.repeat(50)));
+      console.log('\n기본 평가 항목:');
+      console.log('  • 정확성: 요구사항을 정확히 충족하는가');
+      console.log('  • 명확성: 이해하기 쉽고 명확한가');
+      console.log('  • 완전성: 필요한 모든 정보를 포함하는가');
+      console.log('  • 일관성: 스타일과 접근법이 일관되는가');
+      console.log('  • 효율성: 최적화되고 효율적인가');
+    }
+  }
+
+  /**
+   * 평가 결과 표시
+   */
+  displayEvaluation(evaluation) {
+    console.log(chalk.cyan('\n📊 평가 결과'));
+    console.log(chalk.gray('-'.repeat(50)));
+    
+    const score = evaluation.score || 0;
+    const scoreColor = score >= 80 ? 'green' : score >= 60 ? 'yellow' : 'red';
+    
+    console.log(`전체 점수: ${chalk[scoreColor](`${score}/100`)}`);
+    
+    if (evaluation.criteria) {
+      console.log('\n세부 평가:');
+      Object.entries(evaluation.criteria).forEach(([criterion, value]) => {
+        const itemScore = value.score || value;
+        const itemColor = itemScore >= 80 ? 'green' : itemScore >= 60 ? 'yellow' : 'red';
+        console.log(`  • ${criterion}: ${chalk[itemColor](`${itemScore}/100`)}`);
+        if (value.feedback) {
+          console.log(`    ${chalk.gray(value.feedback)}`);
+        }
+      });
+    }
+    
+    if (evaluation.suggestions && evaluation.suggestions.length > 0) {
+      console.log('\n💡 개선 제안:');
+      evaluation.suggestions.forEach((suggestion, index) => {
+        console.log(`  ${index + 1}. ${suggestion}`);
+      });
+    }
+  }
+
+  /**
+   * 코드 평가 결과 표시
+   */
+  displayCodeEvaluation(evaluation) {
+    this.displayEvaluation(evaluation);
+    
+    if (evaluation.issues && evaluation.issues.length > 0) {
+      console.log('\n⚠️  발견된 문제:');
+      evaluation.issues.forEach((issue, index) => {
+        const severity = issue.severity || 'info';
+        const severityColor = severity === 'error' ? 'red' : severity === 'warning' ? 'yellow' : 'gray';
+        console.log(`  ${index + 1}. [${chalk[severityColor](severity.toUpperCase())}] ${issue.message}`);
+        if (issue.line) {
+          console.log(`     ${chalk.gray(`라인 ${issue.line}`)}`);
+        }
+      });
+    }
+  }
+
+  /**
+   * 페르소나 평가 결과 표시
+   */
+  displayPersonaEvaluation(result, personaName) {
+    console.log(chalk.cyan(`\n🎭 페르소나 적합성 평가: ${personaName}`));
+    console.log(chalk.gray('-'.repeat(50)));
+    
+    if (result.isAppropriate) {
+      console.log(chalk.green('✅ 페르소나에 적합한 응답입니다.'));
+    } else {
+      console.log(chalk.red('❌ 페르소나에 적합하지 않은 응답입니다.'));
+    }
+    
+    if (result.confidence) {
+      const confColor = result.confidence >= 0.8 ? 'green' : result.confidence >= 0.6 ? 'yellow' : 'red';
+      console.log(`신뢰도: ${chalk[confColor](`${(result.confidence * 100).toFixed(0)}%`)}`);
+    }
+    
+    if (result.feedback) {
+      console.log(`\n피드백:\n${result.feedback}`);
+    }
+    
+    if (result.characteristics) {
+      console.log('\n발견된 특성:');
+      Object.entries(result.characteristics).forEach(([char, present]) => {
+        const icon = present ? '✅' : '❌';
+        console.log(`  ${icon} ${char}`);
+      });
+    }
+  }
+
+  /**
+   * 평가 결과 저장
+   */
+  async saveEvaluation(evaluation, type, filePath, metadata = {}) {
+    const timestamp = new Date().toISOString();
+    const id = `eval-${type}-${Date.now()}`;
+    
+    const data = {
+      id,
+      type,
+      timestamp,
+      filePath,
+      evaluation,
+      metadata
+    };
+    
+    const savePath = path.join(this.evaluationPath, `${id}.json`);
+    await fs.ensureDir(this.evaluationPath);
+    await fs.writeJson(savePath, data, { spaces: 2 });
+    
+    console.log(chalk.gray(`\n평가 결과 저장됨: ${savePath}`));
+  }
+
+  /**
+   * 모든 평가 결과 로드
+   */
+  async loadAllEvaluations() {
+    const evaluations = [];
+    
+    if (!fs.existsSync(this.evaluationPath)) {
+      return evaluations;
+    }
+    
+    const files = await fs.readdir(this.evaluationPath);
+    for (const file of files) {
+      if (file.endsWith('.json') && file.startsWith('eval-')) {
+        try {
+          const data = await fs.readJson(path.join(this.evaluationPath, file));
+          evaluations.push(data);
+        } catch (error) {
+          // 잘못된 파일 무시
+        }
+      }
+    }
+    
+    return evaluations.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
+  }
+
+  /**
+   * 평가 리포트 생성
+   */
+  createReport(evaluations) {
+    const report = [];
+    
+    report.push('# AIWF 평가 리포트');
+    report.push(`\n생성일: ${new Date().toISOString()}`);
+    report.push(`총 평가 수: ${evaluations.length}`);
+    
+    // 타입별 통계
+    const byType = {};
+    evaluations.forEach(evaluation => {
+      byType[evaluation.type] = (byType[evaluation.type] || 0) + 1;
+    });
+    
+    report.push('\n## 평가 유형별 통계');
+    Object.entries(byType).forEach(([type, count]) => {
+      report.push(`- ${type}: ${count}건`);
+    });
+    
+    // 최근 평가 목록
+    report.push('\n## 최근 평가 (최대 10건)');
+    evaluations.slice(0, 10).forEach((evaluation, index) => {
+      const score = evaluation.evaluation.score || 0;
+      report.push(`\n### ${index + 1}. ${evaluation.type} 평가 - ${evaluation.filePath}`);
+      report.push(`- 시간: ${evaluation.timestamp}`);
+      report.push(`- 점수: ${score}/100`);
+      if (evaluation.evaluation.suggestions) {
+        report.push('- 제안사항:');
+        evaluation.evaluation.suggestions.forEach(s => report.push(`  - ${s}`));
+      }
+    });
+    
+    return report.join('\n');
+  }
+
+  /**
+   * 평가 요약 생성
+   */
+  createSummary(evaluations) {
+    const totalScore = evaluations.reduce((sum, e) => sum + (e.evaluation.score || 0), 0);
+    const avgScore = evaluations.length > 0 ? totalScore / evaluations.length : 0;
+    
+    const summary = [];
+    summary.push(`평균 점수: ${avgScore.toFixed(1)}/100`);
+    summary.push(`총 평가 수: ${evaluations.length}`);
+    
+    // 타입별 평균
+    const typeScores = {};
+    const typeCounts = {};
+    
+    evaluations.forEach(evaluation => {
+      const type = evaluation.type;
+      const score = evaluation.evaluation.score || 0;
+      typeScores[type] = (typeScores[type] || 0) + score;
+      typeCounts[type] = (typeCounts[type] || 0) + 1;
+    });
+    
+    summary.push('\n타입별 평균 점수:');
+    Object.keys(typeScores).forEach(type => {
+      const avg = typeScores[type] / typeCounts[type];
+      summary.push(`  - ${type}: ${avg.toFixed(1)}/100`);
+    });
+    
+    return summary.join('\n');
+  }
+
+  /**
+   * 도움말 표시
+   */
+  showHelp() {
+    console.log(chalk.cyan('🔍 AIWF 평가 도구'));
+    console.log(chalk.gray('-'.repeat(50)));
+    console.log('사용법: aiwf evaluate <명령어> [옵션]');
+    console.log('');
+    console.log('명령어:');
+    console.log('  response <파일>         AI 응답 품질 평가');
+    console.log('  code <파일>             코드 품질 평가');
+    console.log('  persona <파일> <이름>   페르소나 적합성 평가');
+    console.log('  report                  평가 리포트 생성');
+    console.log('  criteria                평가 기준 표시');
+    console.log('');
+    console.log('예시:');
+    console.log('  aiwf evaluate response response.md');
+    console.log('  aiwf evaluate code src/app.js');
+    console.log('  aiwf evaluate persona output.txt architect');
+    console.log('  aiwf evaluate report');
+  }
+}
+
+export default EvaluateCommand;

package/src/commands/persona.js

@@ -6,6 +6,7 @@
  */
 
 import { AIPersonaManager } from '../lib/ai-persona-manager.js';
+import { ResourceLoader } from '../lib/resource-loader.js';
 import path from 'path';
 import chalk from 'chalk';
 import { fileURLToPath } from 'url';
@@ -17,6 +18,7 @@ const __dirname = dirname(__filename);
 class PersonaCommand {
   constructor() {
     this.personaManager = null;
+    this.resourceLoader = new ResourceLoader();
   }
 
   /**
@@ -24,11 +26,15 @@ class PersonaCommand {
    */
   async initPersonaManager() {
     if (!this.personaManager) {
+      // 사용자 디렉토리 초기화
+      await this.resourceLoader.initUserDirectory();
+      
       this.personaManager = new AIPersonaManager({
         personaConfigPath: path.join(process.cwd(), '.aiwf', 'personas'),
         metricsPath: path.join(process.cwd(), '.aiwf', 'metrics'),
         metricsEnabled: true,
-        autoDetectionEnabled: true
+        autoDetectionEnabled: true,
+        resourceLoader: this.resourceLoader
       });
       
       await this.personaManager.init();
@@ -88,21 +94,36 @@ class PersonaCommand {
       console.log(chalk.cyan('🎭 사용 가능한 AI 페르소나'));
       console.log(chalk.gray('-'.repeat(50)));
       
-      // 기본 페르소나 목록을 하드코딩으로 표시 (초기화 문제 회피)
-      const defaultPersonas = [
-        { name: 'architect', description: '시스템 설계 및 아키텍처 전문가' },
-        { name: 'developer', description: '일반 개발자 (기본값)' },
-        { name: 'reviewer', description: '코드 리뷰 및 품질 관리 전문가' },
-        { name: 'debugger', description: '디버깅 및 문제 해결 전문가' },
-        { name: 'optimizer', description: '성능 최적화 전문가' },
-        { name: 'security', description: '보안 및 취약점 분석 전문가' },
-        { name: 'documenter', description: '문서화 및 기술 작성 전문가' }
-      ];
-      
-      defaultPersonas.forEach(persona => {
-        const displayName = chalk.yellow(persona.name);
-        console.log(`  ${displayName} - ${persona.description}`);
-      });
+      // ResourceLoader를 사용하여 페르소나 목록 가져오기
+      try {
+        const personas = await this.resourceLoader.listPersonas();
+        
+        for (const personaName of personas) {
+          try {
+            const persona = await this.resourceLoader.loadPersona(personaName);
+            const displayName = chalk.yellow(personaName);
+            const description = persona.description || '설명 없음';
+            console.log(`  ${displayName} - ${description}`);
+          } catch (error) {
+            // 개별 페르소나 로드 실패 시 건너뛰기
+            console.log(`  ${chalk.yellow(personaName)} - ${chalk.gray('(로드 실패)')}`);
+          }
+        }
+      } catch (error) {
+        // 페르소나 목록 가져오기 실패 시 기본 목록 표시
+        const defaultPersonas = [
+          { name: 'architect', description: '시스템 설계 및 아키텍처 전문가' },
+          { name: 'developer', description: '일반 개발자 (기본값)' },
+          { name: 'reviewer', description: '코드 리뷰 및 품질 관리 전문가' },
+          { name: 'analyst', description: '비즈니스 분석가' },
+          { name: 'tester', description: '테스트 엔지니어' }
+        ];
+        
+        defaultPersonas.forEach(persona => {
+          const displayName = chalk.yellow(persona.name);
+          console.log(`  ${displayName} - ${persona.description}`);
+        });
+      }
       
       console.log(chalk.gray('\n' + '-'.repeat(50)));
       console.log(chalk.gray('사용법: aiwf persona set <페르소나명>'));