aiwf 0.3.1 → 0.3.2

package/claude-code/aiwf/ko/.aiwf/06_FEATURE_LEDGERS/schemas/feature_validator.cjs

@@ -0,0 +1,406 @@
+/**
+ * AIWF Feature Ledger 스키마 검증 함수
+ * Feature 데이터의 유효성을 검증하고 오류를 반환합니다.
+ */
+
+const Ajv = require('ajv');
+const addFormats = require('ajv-formats');
+const fs = require('fs');
+const path = require('path');
+
+class FeatureValidator {
+  constructor() {
+    this.ajv = new Ajv({ allErrors: true, strict: false });
+    addFormats(this.ajv);
+    
+    // Feature 스키마 로드
+    const schemaPath = path.join(__dirname, 'feature_schema.json');
+    this.schema = JSON.parse(fs.readFileSync(schemaPath, 'utf8'));
+    this.validate = this.ajv.compile(this.schema);
+  }
+
+  /**
+   * Feature 데이터 검증
+   * @param {Object} featureData - 검증할 Feature 데이터
+   * @returns {Object} 검증 결과 { valid: boolean, errors: Array }
+   */
+  validateFeature(featureData) {
+    const isValid = this.validate(featureData);
+    
+    return {
+      valid: isValid,
+      errors: isValid ? [] : this.formatErrors(this.validate.errors),
+      data: featureData
+    };
+  }
+
+  /**
+   * Feature ID 형식 검증
+   * @param {string} featureId - 검증할 Feature ID
+   * @returns {boolean} 유효성 여부
+   */
+  validateFeatureId(featureId) {
+    const pattern = /^FL[0-9]{3}$/;
+    return pattern.test(featureId);
+  }
+
+  /**
+   * 마일스톤 ID 형식 검증
+   * @param {string} milestoneId - 검증할 마일스톤 ID
+   * @returns {boolean} 유효성 여부
+   */
+  validateMilestoneId(milestoneId) {
+    const pattern = /^M[0-9]{2}$/;
+    return pattern.test(milestoneId);
+  }
+
+  /**
+   * Feature 상태 검증
+   * @param {string} status - 검증할 상태
+   * @returns {boolean} 유효성 여부
+   */
+  validateStatus(status) {
+    const validStatuses = ['draft', 'active', 'on-hold', 'completed', 'archived'];
+    return validStatuses.includes(status);
+  }
+
+  /**
+   * 우선순위 검증
+   * @param {string} priority - 검증할 우선순위
+   * @returns {boolean} 유효성 여부
+   */
+  validatePriority(priority) {
+    const validPriorities = ['low', 'medium', 'high', 'critical'];
+    return validPriorities.includes(priority);
+  }
+
+  /**
+   * 의존성 검증 (순환 참조 확인)
+   * @param {string} featureId - 현재 Feature ID
+   * @param {Array} dependencies - 의존성 목록
+   * @param {Array} allFeatures - 전체 Feature 목록
+   * @returns {Object} 검증 결과
+   */
+  validateDependencies(featureId, dependencies, allFeatures = []) {
+    const result = {
+      valid: true,
+      errors: [],
+      circularDependencies: []
+    };
+
+    // 의존성 Feature ID 형식 검증
+    for (const depId of dependencies) {
+      if (!this.validateFeatureId(depId)) {
+        result.valid = false;
+        result.errors.push(`Invalid dependency feature ID format: ${depId}`);
+      }
+    }
+
+    // 순환 참조 검증
+    const visited = new Set();
+    const recursionStack = new Set();
+    
+    const hasCycle = (currentId, deps) => {
+      if (recursionStack.has(currentId)) {
+        result.circularDependencies.push(currentId);
+        return true;
+      }
+      
+      if (visited.has(currentId)) {
+        return false;
+      }
+      
+      visited.add(currentId);
+      recursionStack.add(currentId);
+      
+      const currentFeature = allFeatures.find(f => f.feature_id === currentId);
+      const currentDeps = currentFeature ? currentFeature.dependencies : [];
+      
+      for (const depId of currentDeps) {
+        if (hasCycle(depId, allFeatures)) {
+          return true;
+        }
+      }
+      
+      recursionStack.delete(currentId);
+      return false;
+    };
+
+    if (hasCycle(featureId, allFeatures)) {
+      result.valid = false;
+      result.errors.push(`Circular dependency detected for feature ${featureId}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Git 브랜치명 검증
+   * @param {Array} branches - 브랜치명 배열
+   * @returns {Object} 검증 결과
+   */
+  validateGitBranches(branches) {
+    const result = {
+      valid: true,
+      errors: []
+    };
+
+    const branchPattern = /^[a-zA-Z0-9/_-]+$/;
+    
+    for (const branch of branches) {
+      if (!branchPattern.test(branch)) {
+        result.valid = false;
+        result.errors.push(`Invalid git branch name: ${branch}`);
+      }
+      
+      // Git 브랜치명 길이 제한 (일반적으로 255자)
+      if (branch.length > 255) {
+        result.valid = false;
+        result.errors.push(`Branch name too long: ${branch}`);
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * 날짜 형식 검증
+   * @param {string} dateString - 검증할 날짜 문자열
+   * @returns {boolean} 유효성 여부
+   */
+  validateDateTime(dateString) {
+    try {
+      const date = new Date(dateString);
+      return date instanceof Date && !isNaN(date) && dateString === date.toISOString();
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * 작업 시간 검증
+   * @param {number} estimated - 예상 시간
+   * @param {number} actual - 실제 시간
+   * @returns {Object} 검증 결과
+   */
+  validateWorkHours(estimated, actual) {
+    const result = {
+      valid: true,
+      errors: [],
+      warnings: []
+    };
+
+    // 기본 범위 검증
+    if (estimated < 0 || estimated > 1000) {
+      result.valid = false;
+      result.errors.push(`Estimated hours out of range: ${estimated}`);
+    }
+
+    if (actual < 0 || actual > 1000) {
+      result.valid = false;
+      result.errors.push(`Actual hours out of range: ${actual}`);
+    }
+
+    // 비즈니스 로직 검증
+    if (actual > estimated * 2) {
+      result.warnings.push(`Actual hours significantly exceed estimated: ${actual} vs ${estimated}`);
+    }
+
+    if (estimated > 0 && actual === 0) {
+      result.warnings.push('Work has been estimated but no actual hours recorded');
+    }
+
+    return result;
+  }
+
+  /**
+   * 태그 검증
+   * @param {Array} tags - 태그 배열
+   * @returns {Object} 검증 결과
+   */
+  validateTags(tags) {
+    const result = {
+      valid: true,
+      errors: [],
+      warnings: []
+    };
+
+    const validCategories = [
+      'frontend', 'backend', 'api', 'database', 'ui', 'ux',
+      'feature', 'enhancement', 'bugfix', 'refactor', 'docs',
+      'simple', 'complex', 'critical', 'auth', 'payment',
+      'notification', 'search', 'admin', 'security', 'core'
+    ];
+
+    for (const tag of tags) {
+      // 길이 검증
+      if (tag.length < 1 || tag.length > 30) {
+        result.valid = false;
+        result.errors.push(`Tag length out of range: ${tag}`);
+      }
+
+      // 형식 검증 (알파벳, 숫자, 하이픈만 허용)
+      if (!/^[a-zA-Z0-9-_]+$/.test(tag)) {
+        result.valid = false;
+        result.errors.push(`Invalid tag format: ${tag}`);
+      }
+
+      // 권장 태그 체크 (경고)
+      if (!validCategories.includes(tag.toLowerCase())) {
+        result.warnings.push(`Non-standard tag used: ${tag}`);
+      }
+    }
+
+    // 중복 태그 체크
+    const uniqueTags = new Set(tags);
+    if (uniqueTags.size !== tags.length) {
+      result.warnings.push('Duplicate tags found');
+    }
+
+    return result;
+  }
+
+  /**
+   * 종합 Feature 검증
+   * @param {Object} featureData - Feature 데이터
+   * @param {Array} allFeatures - 전체 Feature 목록 (의존성 검증용)
+   * @returns {Object} 종합 검증 결과
+   */
+  validateFeatureComprehensive(featureData, allFeatures = []) {
+    const result = {
+      valid: true,
+      errors: [],
+      warnings: [],
+      details: {}
+    };
+
+    // 기본 스키마 검증
+    const schemaResult = this.validateFeature(featureData);
+    result.valid = result.valid && schemaResult.valid;
+    result.errors.push(...schemaResult.errors);
+
+    // 의존성 검증
+    if (featureData.dependencies && featureData.dependencies.length > 0) {
+      const depResult = this.validateDependencies(
+        featureData.feature_id,
+        featureData.dependencies,
+        allFeatures
+      );
+      result.valid = result.valid && depResult.valid;
+      result.errors.push(...depResult.errors);
+      result.details.dependencies = depResult;
+    }
+
+    // Git 브랜치 검증
+    if (featureData.git_branches) {
+      const branchResult = this.validateGitBranches(featureData.git_branches);
+      result.valid = result.valid && branchResult.valid;
+      result.errors.push(...branchResult.errors);
+      result.details.git_branches = branchResult;
+    }
+
+    // 작업 시간 검증
+    const hoursResult = this.validateWorkHours(
+      featureData.estimated_hours,
+      featureData.actual_hours
+    );
+    result.valid = result.valid && hoursResult.valid;
+    result.errors.push(...hoursResult.errors);
+    result.warnings.push(...hoursResult.warnings);
+    result.details.work_hours = hoursResult;
+
+    // 태그 검증
+    if (featureData.tags) {
+      const tagResult = this.validateTags(featureData.tags);
+      result.valid = result.valid && tagResult.valid;
+      result.errors.push(...tagResult.errors);
+      result.warnings.push(...tagResult.warnings);
+      result.details.tags = tagResult;
+    }
+
+    return result;
+  }
+
+  /**
+   * 오류 메시지 포맷팅
+   * @param {Array} errors - AJV 오류 배열
+   * @returns {Array} 포맷된 오류 메시지
+   */
+  formatErrors(errors) {
+    return errors.map(error => {
+      const { instancePath, message, params } = error;
+      const field = instancePath.replace('/', '') || 'root';
+      
+      return {
+        field,
+        message,
+        value: params?.missingProperty || 'unknown',
+        path: instancePath
+      };
+    });
+  }
+
+  /**
+   * 검증 리포트 생성
+   * @param {Object} validationResult - 검증 결과
+   * @returns {string} 포맷된 리포트
+   */
+  generateReport(validationResult) {
+    const { valid, errors, warnings, details } = validationResult;
+    
+    let report = `\n=== Feature Validation Report ===\n`;
+    report += `Status: ${valid ? '✅ VALID' : '❌ INVALID'}\n`;
+    
+    if (errors.length > 0) {
+      report += `\nErrors (${errors.length}):\n`;
+      errors.forEach((error, index) => {
+        report += `  ${index + 1}. ${error.field}: ${error.message}\n`;
+      });
+    }
+    
+    if (warnings.length > 0) {
+      report += `\nWarnings (${warnings.length}):\n`;
+      warnings.forEach((warning, index) => {
+        report += `  ${index + 1}. ${warning}\n`;
+      });
+    }
+    
+    if (details) {
+      report += `\nValidation Details:\n`;
+      Object.keys(details).forEach(key => {
+        const detail = details[key];
+        report += `  ${key}: ${detail.valid ? '✅' : '❌'}\n`;
+      });
+    }
+    
+    return report;
+  }
+}
+
+// 사용 예시 및 테스트
+if (require.main === module) {
+  const validator = new FeatureValidator();
+  
+  // 샘플 데이터 검증
+  const sampleFeature = {
+    feature_id: "FL001",
+    title: "사용자 인증 시스템",
+    description: "JWT 기반 사용자 인증 시스템 구현",
+    status: "active",
+    priority: "high",
+    milestone_id: "M02",
+    assignee: "moonklabs",
+    created_date: "2025-07-08T20:55:00+0900",
+    updated_date: "2025-07-08T20:55:00+0900",
+    estimated_hours: 24,
+    actual_hours: 8,
+    tags: ["authentication", "security", "core"],
+    dependencies: [],
+    git_branches: ["feature/FL001-user-auth"]
+  };
+  
+  const result = validator.validateFeatureComprehensive(sampleFeature);
+  console.log(validator.generateReport(result));
+}
+
+module.exports = FeatureValidator;

package/claude-code/aiwf/ko/.claude/commands/aiwf/aiwf_compress_aggressive_persona.md

@@ -0,0 +1,53 @@
+# aiwf compress-aggressive-persona
+
+활성화된 페르소나를 고려하여 공격적 모드로 컨텍스트를 압축합니다.
+
+## 실행
+
+```javascript
+const { spawn } = require('child_process');
+const path = require('path');
+
+// .aiwf 디렉토리로 이동하여 명령 실행
+const cwd = path.join(process.cwd(), '.aiwf');
+const proc = spawn('node', [
+  '../claude-code/aiwf/ko/commands/compress-context.js',
+  'aggressive',
+  '--persona'
+], { cwd, stdio: 'inherit' });
+
+proc.on('error', (err) => {
+  console.error('명령 실행 실패:', err.message);
+});
+```
+
+## 설명
+
+페르소나 특성을 고려하면서도 50-70%의 높은 압축률을 목표로 합니다. 페르소나 관련 핵심 정보는 보존하되, 나머지는 적극적으로 요약합니다.
+
+### 특징
+
+- 페르소나 중심 요약 생성
+- 핵심 패턴만 보존
+- 중요도가 낮은 섹션은 요약으로 대체
+- 페르소나별 summarization focus 적용
+
+## 압축 결과
+
+압축 후 페르소나별 요약이 문서 하단에 추가됩니다:
+
+```markdown
+---
+### [페르소나명] 관점 요약
+
+주요 내용 ([페르소나의 focus]):
+- 핵심 포인트 1
+- 핵심 포인트 2
+- ...
+---
+```
+
+## 주의사항
+
+- 매우 높은 압축률로 인해 일부 세부 정보가 손실될 수 있습니다
+- 중요한 문서는 백업 후 사용을 권장합니다

package/claude-code/aiwf/ko/.claude/commands/aiwf/aiwf_compress_context.md

@@ -0,0 +1,116 @@
+# Context 압축 - 토큰 절약 실행
+
+토큰 사용량을 줄이기 위해 프로젝트 컨텍스트를 압축합니다. 3단계 압축 모드와 실시간 토큰 모니터링을 제공합니다.
+
+**중요사항:**
+- 기본 모드는 'balanced'로 30-50% 토큰 절약을 목표로 합니다
+- 압축 전후 토큰 사용량과 절약률을 실시간으로 표시합니다
+- 중요한 정보는 모든 모드에서 보존됩니다
+
+## 사용법
+
+```
+/project:aiwf:compress_context [mode] [target]
+```
+
+### 파라미터
+
+- `mode` (선택적): 압축 모드
+  - `aggressive`: 50-70% 토큰 절약 (critical/high 정보만 유지)
+  - `balanced`: 30-50% 토큰 절약 (기본값, medium 이상 정보 유지)
+  - `minimal`: 10-30% 토큰 절약 (모든 정보 유지, 포맷팅만 최적화)
+
+- `target` (선택적): 압축 대상
+  - 파일 경로: 특정 파일 압축
+  - 디렉토리 경로: 디렉토리 내 모든 마크다운 파일 압축
+  - 생략 시: 현재 프로젝트의 주요 문서 압축
+
+## 압축 전략
+
+### Aggressive 모드 (50-70% 압축)
+- Critical/High 중요도 섹션만 유지
+- 코드 예제 대폭 축소
+- 중복 정보 완전 제거
+- Output Log, 히스토리 등 제거
+
+### Balanced 모드 (30-50% 압축)
+- Critical/High/Medium 중요도 섹션 유지
+- 코드 예제 선택적 유지
+- 중복 정보 부분 제거
+- 오래된 로그만 제거
+
+### Minimal 모드 (10-30% 압축)
+- 모든 중요도 유지
+- 공백 및 형식 정리
+- 명백한 중복만 제거
+- 안전한 압축
+
+## 실행 단계
+
+1. **압축 대상 파악**
+   - 대상 파일/디렉토리 확인
+   - 원본 토큰 수 계산
+
+2. **압축 모드 적용**
+   - 선택된 모드에 따라 압축 전략 실행
+   - 중요도 기반 섹션 필터링
+   - 압축 알고리즘 적용
+
+3. **압축 결과 검증**
+   - 압축 후 토큰 수 계산
+   - 절약률 및 품질 점수 표시
+   - Critical 정보 보존 검증
+
+4. **압축 파일 생성**
+   - 압축된 컨텐츠를 새 파일로 저장
+   - 원본 파일은 보존
+   - 압축 메타데이터 기록
+
+## 출력 형식
+
+```
+🗜️ Context 압축 시작
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+압축 모드: balanced
+대상: /workspace/project/.aiwf/
+
+📊 압축 전 통계:
+- 총 파일 수: 15
+- 원본 토큰: 45,320
+- 원본 크기: 125.4 KB
+
+⚙️ 압축 진행 중...
+✓ PROJECT_MANIFEST.md (5,320 → 2,890 토큰, -45.6%)
+✓ ARCHITECTURE.md (8,210 → 4,105 토큰, -50.0%)
+✓ M02_milestone_meta.md (3,450 → 2,070 토큰, -40.0%)
+... [추가 파일들]
+
+📊 압축 후 통계:
+- 압축된 토큰: 27,192
+- 절약된 토큰: 18,128
+- 토큰 절약률: 40.0%
+- 압축 시간: 2.3초
+- 품질 점수: 92/100
+
+✅ 압축 완료!
+압축된 파일 위치: /workspace/project/.aiwf_compressed/
+```
+
+## 품질 보증
+
+- **Critical 정보 보존**: 목표, 요구사항, 승인 기준은 항상 유지
+- **구조 보존**: 문서의 논리적 구조와 계층 유지
+- **가독성 유지**: 압축 후에도 읽기 쉬운 형태 유지
+- **복원 가능**: 압축 메타데이터로 필요시 복원 지원
+
+## 권장 사용 시나리오
+
+1. **대규모 프로젝트 리뷰 시**: aggressive 모드로 핵심만 빠르게 파악
+2. **일반 개발 작업**: balanced 모드로 효율적인 컨텍스트 관리
+3. **디버깅/상세 분석**: minimal 모드로 모든 정보 유지하며 최적화
+
+## 주의사항
+
+- 압축된 파일은 별도 디렉토리에 저장되며 원본은 보존됩니다
+- 압축 시 일부 형식이나 세부 정보가 손실될 수 있습니다
+- Critical로 표시된 정보는 모든 모드에서 보존됩니다

package/claude-code/aiwf/ko/.claude/commands/aiwf/aiwf_compress_minimal_persona.md

@@ -0,0 +1,48 @@
+# aiwf compress-minimal-persona
+
+활성화된 페르소나를 고려하여 최소 모드로 컨텍스트를 압축합니다.
+
+## 실행
+
+```javascript
+const { spawn } = require('child_process');
+const path = require('path');
+
+// .aiwf 디렉토리로 이동하여 명령 실행
+const cwd = path.join(process.cwd(), '.aiwf');
+const proc = spawn('node', [
+  '../claude-code/aiwf/ko/commands/compress-context.js',
+  'minimal',
+  '--persona'
+], { cwd, stdio: 'inherit' });
+
+proc.on('error', (err) => {
+  console.error('명령 실행 실패:', err.message);
+});
+```
+
+## 설명
+
+페르소나 특성을 고려하면서도 최소한의 압축만 수행합니다. 10-30%의 낮은 압축률로 원본 내용을 최대한 보존합니다.
+
+### 압축 전략
+
+- 페르소나 관련 패턴은 100% 보존
+- 중복 내용만 제거
+- 불필요한 공백과 포맷팅 정리
+- 페르소나별 중요도 점수가 평균 이상인 섹션은 그대로 유지
+
+## 적합한 사용 사례
+
+- 중요한 기술 문서
+- 상세한 API 문서
+- 보안 관련 문서
+- 데이터 분석 리포트
+
+## 결과
+
+압축 후에도 다음이 보장됩니다:
+- 모든 페르소나 관련 키워드 보존
+- 문서 구조 완전 유지
+- 코드 블록과 예제 보존
+- 테이블과 다이어그램 유지

package/claude-code/aiwf/ko/.claude/commands/aiwf/aiwf_compress_stats.md

@@ -0,0 +1,79 @@
+# aiwf compress-stats
+
+페르소나별 압축 통계를 확인합니다.
+
+## 실행
+
+```javascript
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+
+// PersonaAwareCompressor import
+const { PersonaAwareCompressor } = require(path.join(
+  process.cwd(), 
+  'claude-code/aiwf/ko/utils/persona-aware-compressor.js'
+));
+
+try {
+  const compressor = new PersonaAwareCompressor();
+  const stats = compressor.getPersonaCompressionStats();
+  
+  console.log(chalk.cyan('📊 페르소나별 압축 통계'));
+  console.log(chalk.gray('━'.repeat(50)));
+  
+  if (stats.currentPersona) {
+    console.log(`현재 페르소나: ${chalk.yellow(stats.currentPersona)}`);
+    
+    if (stats.strategy) {
+      console.log('\n📋 현재 페르소나 압축 전략:');
+      console.log(`- 포커스 영역: ${stats.strategy.focusAreas.join(', ')}`);
+      console.log(`- 요약 초점: ${stats.strategy.summarizationFocus}`);
+      console.log(`- 보존 패턴: ${stats.strategy.preservePatterns.slice(0, 5).join(', ')}...`);
+    }
+  } else {
+    console.log(chalk.yellow('⚠️  활성화된 페르소나가 없습니다.'));
+  }
+  
+  const avgRatios = stats.averageRatioByPersona;
+  if (Object.keys(avgRatios).length > 0) {
+    console.log('\n📈 페르소나별 평균 압축률:');
+    Object.entries(avgRatios).forEach(([persona, ratio]) => {
+      const personaNames = {
+        architect: 'Architect',
+        security: 'Security Expert',
+        frontend: 'Frontend Developer',
+        backend: 'Backend Developer',
+        data_analyst: 'Data Analyst'
+      };
+      console.log(`- ${personaNames[persona] || persona}: ${chalk.green(ratio + '%')}`);
+    });
+  } else {
+    console.log('\n압축 히스토리가 없습니다.');
+  }
+  
+} catch (error) {
+  console.error(chalk.red('오류:'), error.message);
+}
+```
+
+## 설명
+
+페르소나별 압축 통계와 현재 활성화된 페르소나의 압축 전략을 확인합니다.
+
+### 제공 정보
+
+1. **현재 페르소나 정보**
+   - 활성 페르소나 이름
+   - 압축 전략 상세
+   - 보존 패턴 목록
+
+2. **압축 히스토리 통계**
+   - 페르소나별 평균 압축률
+   - 압축 성능 비교
+
+## 활용 방법
+
+- 페르소나별 압축 효율성 비교
+- 최적의 압축 모드 선택
+- 압축 전략 개선점 파악