aiwf 0.3.1 → 0.3.2

package/.aiwf/scripts/test-commit-parsing.cjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+
+const { extractFeatureId } = require('./git-integration.cjs');
+
+// 테스트 케이스
+const testCases = [
+    // 기본 패턴
+    { message: 'FL001 implement user login', expected: 'FL001' },
+    { message: 'Add validation for FL002', expected: 'FL002' },
+    { message: 'Quick fix FL999', expected: 'FL999' },
+    
+    // 브래킷 패턴
+    { message: '[FL001] implement user login', expected: 'FL001' },
+    { message: 'Add validation [FL002]', expected: 'FL002' },
+    { message: '[FL003] - fix bug in authentication', expected: 'FL003' },
+    
+    // Conventional Commits
+    { message: 'feat(FL001): implement JWT token generation', expected: 'FL001' },
+    { message: 'fix(FL002): resolve token expiration bug', expected: 'FL002' },
+    { message: 'docs(FL003): update API documentation', expected: 'FL003' },
+    { message: 'style(FL004): format code according to guidelines', expected: 'FL004' },
+    { message: 'refactor(FL005): simplify authentication logic', expected: 'FL005' },
+    { message: 'test(FL006): add unit tests for auth service', expected: 'FL006' },
+    { message: 'chore(FL007): update dependencies', expected: 'FL007' },
+    
+    // 해시태그 패턴
+    { message: '#FL001 implement feature', expected: 'FL001' },
+    { message: 'Update docs #FL002', expected: 'FL002' },
+    { message: 'Bug fix #FL003 #FL004', expected: 'FL003' }, // 첫 번째만
+    
+    // 관련 패턴
+    { message: 'relates to FL001', expected: 'FL001' },
+    { message: 'This commit relates to FL002', expected: 'FL002' },
+    { message: 'Related to FL003 and FL004', expected: 'FL003' },
+    
+    // 복합 케이스
+    { message: 'feat(FL001): implement feature [FL002] #FL003', expected: 'FL001' }, // 첫 번째 우선
+    { message: 'WIP: FL001 - work in progress', expected: 'FL001' },
+    
+    // 실패해야 하는 케이스
+    { message: 'No feature ID in this commit', expected: null },
+    { message: 'FL01 is too short', expected: null },
+    { message: 'FL0001 is too long', expected: null },
+    { message: 'fl001 lowercase should not match', expected: null },
+    { message: 'XL001 wrong prefix', expected: null },
+];
+
+// 테스트 실행
+function runTests() {
+    console.log('AIWF Commit Message Parsing Test\n');
+    console.log('Testing Feature ID extraction patterns...\n');
+    
+    let passed = 0;
+    let failed = 0;
+    
+    testCases.forEach((testCase, index) => {
+        const result = extractFeatureId(testCase.message);
+        const success = result === testCase.expected;
+        
+        if (success) {
+            passed++;
+            console.log(`✓ Test ${index + 1}: "${testCase.message}"`);
+            console.log(`  Expected: ${testCase.expected}, Got: ${result}\n`);
+        } else {
+            failed++;
+            console.log(`✗ Test ${index + 1}: "${testCase.message}"`);
+            console.log(`  Expected: ${testCase.expected}, Got: ${result}\n`);
+        }
+    });
+    
+    const total = passed + failed;
+    const accuracy = (passed / total * 100).toFixed(2);
+    
+    console.log('\n' + '='.repeat(50));
+    console.log(`\nTest Results:`);
+    console.log(`  Total tests: ${total}`);
+    console.log(`  Passed: ${passed}`);
+    console.log(`  Failed: ${failed}`);
+    console.log(`  Accuracy: ${accuracy}%`);
+    
+    if (accuracy >= 95) {
+        console.log(`\n✓ Success! Parsing accuracy meets the 95% requirement.`);
+    } else {
+        console.log(`\n✗ Failed! Parsing accuracy (${accuracy}%) is below the 95% requirement.`);
+        process.exit(1);
+    }
+}
+
+// 추가 테스트: 실제 Git 로그에서 테스트
+async function testWithGitLog() {
+    const { exec } = require('child_process');
+    const util = require('util');
+    const execAsync = util.promisify(exec);
+    
+    try {
+        console.log('\n\n' + '='.repeat(50));
+        console.log('\nTesting with recent Git commits...\n');
+        
+        const { stdout } = await execAsync('git log --oneline -20');
+        const commits = stdout.trim().split('\n');
+        
+        let foundCount = 0;
+        commits.forEach(commit => {
+            const featureId = extractFeatureId(commit);
+            if (featureId) {
+                foundCount++;
+                console.log(`✓ Found ${featureId} in: ${commit}`);
+            }
+        });
+        
+        console.log(`\nFound Feature IDs in ${foundCount} out of ${commits.length} recent commits`);
+    } catch (error) {
+        console.log('Could not test with Git log (not in a Git repository or no commits)');
+    }
+}
+
+// 메인 실행
+async function main() {
+    runTests();
+    await testWithGitLog();
+}
+
+if (require.main === module) {
+    main();
+}

package/.aiwf/scripts/update-feature-status.cjs

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+
+const fs = require('fs').promises;
+const path = require('path');
+const { parseYamlFrontmatter, updateYamlFrontmatter, getFeaturePath } = require('./git-integration.cjs');
+
+// Feature 상태 업데이트 함수
+async function updateFeatureStatus(featureId, newStatus) {
+    const featurePath = await getFeaturePath(featureId);
+    if (!featurePath) {
+        console.error(`Feature ${featureId} not found`);
+        return false;
+    }
+
+    try {
+        const content = await fs.readFile(featurePath, 'utf-8');
+        const metadata = parseYamlFrontmatter(content);
+        
+        if (!metadata) {
+            console.error(`Invalid feature file format: ${featurePath}`);
+            return false;
+        }
+
+        // 상태 업데이트
+        const oldStatus = metadata.status;
+        metadata.status = newStatus;
+        
+        // 완료 시간 기록
+        if (newStatus === 'completed' && !metadata.actual_completion) {
+            metadata.actual_completion = new Date().toISOString().split('T')[0];
+            metadata.progress_percentage = 100;
+        }
+
+        // 마지막 업데이트 시간
+        metadata.last_updated = new Date().toISOString().replace('T', ' ').substring(0, 16);
+
+        // 파일 업데이트
+        const updatedContent = updateYamlFrontmatter(content, metadata);
+        await fs.writeFile(featurePath, updatedContent);
+
+        // 상태에 따라 파일 이동
+        if (oldStatus !== newStatus) {
+            await moveFeatureFile(featureId, featurePath, oldStatus, newStatus);
+        }
+
+        console.log(`✓ Updated feature ${featureId} status: ${oldStatus} → ${newStatus}`);
+        return true;
+    } catch (error) {
+        console.error(`Error updating feature status: ${error.message}`);
+        return false;
+    }
+}
+
+// Feature 파일 이동 (상태 변경 시)
+async function moveFeatureFile(featureId, currentPath, oldStatus, newStatus) {
+    const FEATURE_LEDGERS_PATH = path.join(process.cwd(), '.aiwf', '06_FEATURE_LEDGERS');
+    const statusFolderMap = {
+        'active': 'active',
+        'in_progress': 'active',
+        'planned': 'active',
+        'completed': 'completed',
+        'archived': 'archived',
+        'paused': 'active'
+    };
+
+    const oldFolder = statusFolderMap[oldStatus] || 'active';
+    const newFolder = statusFolderMap[newStatus] || 'active';
+
+    if (oldFolder === newFolder) {
+        return; // 같은 폴더면 이동 불필요
+    }
+
+    try {
+        const fileName = path.basename(currentPath);
+        const newPath = path.join(FEATURE_LEDGERS_PATH, newFolder, fileName);
+        
+        // 대상 폴더 확인 및 생성
+        await fs.mkdir(path.dirname(newPath), { recursive: true });
+        
+        // 파일 이동
+        await fs.rename(currentPath, newPath);
+        
+        console.log(`✓ Moved feature file to ${newFolder}/`);
+    } catch (error) {
+        console.error(`Warning: Could not move feature file: ${error.message}`);
+    }
+}
+
+// Feature 진행률 계산 및 업데이트
+async function updateFeatureProgress(featureId) {
+    const featurePath = await getFeaturePath(featureId);
+    if (!featurePath) {
+        console.error(`Feature ${featureId} not found`);
+        return false;
+    }
+
+    try {
+        const content = await fs.readFile(featurePath, 'utf-8');
+        const metadata = parseYamlFrontmatter(content);
+        
+        if (!metadata) {
+            console.error(`Invalid feature file format: ${featurePath}`);
+            return false;
+        }
+
+        // 진행률 계산 로직
+        let progress = 0;
+        
+        // 1. 체크리스트 기반 (40%)
+        if (metadata.checklist_items_total && metadata.checklist_items_total > 0) {
+            const checklistProgress = (metadata.checklist_items_completed || 0) / metadata.checklist_items_total;
+            progress += checklistProgress * 40;
+        }
+
+        // 2. 태스크 완료 기반 (40%)
+        if (metadata.tasks && metadata.tasks.length > 0) {
+            // 여기서는 단순히 태스크 수로 계산 (실제로는 각 태스크 상태를 확인해야 함)
+            const taskProgress = 0.5; // 임시값
+            progress += taskProgress * 40;
+        }
+
+        // 3. 시간 경과 기반 (20%)
+        if (metadata.estimated_completion && metadata.created_date) {
+            const created = new Date(metadata.created_date);
+            const estimated = new Date(metadata.estimated_completion);
+            const now = new Date();
+            
+            const totalDays = (estimated - created) / (1000 * 60 * 60 * 24);
+            const elapsedDays = (now - created) / (1000 * 60 * 60 * 24);
+            
+            if (totalDays > 0) {
+                const timeProgress = Math.min(elapsedDays / totalDays, 1);
+                progress += timeProgress * 20;
+            }
+        }
+
+        // 진행률 업데이트
+        metadata.progress_percentage = Math.round(progress);
+        metadata.last_updated = new Date().toISOString().replace('T', ' ').substring(0, 16);
+
+        // 파일 업데이트
+        const updatedContent = updateYamlFrontmatter(content, metadata);
+        await fs.writeFile(featurePath, updatedContent);
+
+        console.log(`✓ Updated feature ${featureId} progress: ${metadata.progress_percentage}%`);
+        return true;
+    } catch (error) {
+        console.error(`Error updating feature progress: ${error.message}`);
+        return false;
+    }
+}
+
+// 메인 함수
+async function main() {
+    const args = process.argv.slice(2);
+    const featureId = args[0];
+    const newStatus = args[1];
+
+    if (!featureId) {
+        console.error('Usage: update-feature-status.js <feature-id> [status]');
+        console.error('\nStatus options:');
+        console.error('  active      Feature is being worked on');
+        console.error('  completed   Feature implementation is complete');
+        console.error('  paused      Work is temporarily halted');
+        console.error('  archived    Feature is no longer relevant');
+        console.error('\nOr update progress:');
+        console.error('  update-feature-status.js <feature-id> --progress');
+        process.exit(1);
+    }
+
+    if (newStatus === '--progress') {
+        await updateFeatureProgress(featureId);
+    } else if (newStatus) {
+        const validStatuses = ['active', 'completed', 'paused', 'archived', 'in_progress', 'planned'];
+        if (!validStatuses.includes(newStatus)) {
+            console.error(`Invalid status: ${newStatus}`);
+            console.error(`Valid statuses: ${validStatuses.join(', ')}`);
+            process.exit(1);
+        }
+        await updateFeatureStatus(featureId, newStatus);
+    } else {
+        // 상태를 지정하지 않으면 진행률만 업데이트
+        await updateFeatureProgress(featureId);
+    }
+}
+
+// 스크립트 실행
+if (require.main === module) {
+    main().catch(error => {
+        console.error(`Fatal error: ${error.message}`);
+        process.exit(1);
+    });
+}
+
+module.exports = {
+    updateFeatureStatus,
+    updateFeatureProgress
+};

package/.aiwf/templates/README.md

@@ -0,0 +1,78 @@
+# AIWF 프로젝트 템플릿
+
+이 디렉토리에는 AIWF 프로젝트 템플릿이 포함되어 있습니다.
+
+## 사용 가능한 템플릿
+
+### 1. web-app (웹 애플리케이션)
+- React 18 + TypeScript
+- Vite 빌드 도구
+- Tailwind CSS
+- React Router
+- Zustand 상태 관리
+- AIWF 대시보드 통합
+
+### 2. api-server (API 서버)
+- Express + TypeScript
+- JWT 인증
+- Swagger 문서화
+- 에러 핸들링
+- AIWF API 엔드포인트
+
+### 3. npm-library (NPM 라이브러리)
+- TypeScript 기반
+- Rollup 번들링
+- Jest 테스트
+- 듀얼 모듈 시스템 (ESM/CJS)
+- 자동 버전 관리
+
+## 템플릿 사용법
+
+```bash
+# 대화형 모드
+aiwf create
+
+# 직접 지정
+aiwf create web-app my-app
+
+# 오프라인 모드
+aiwf create --offline web-app my-app
+```
+
+## 템플릿 구조
+
+각 템플릿은 다음 구조를 따릅니다:
+
+```
+template-name/
+├── config.json       # 템플릿 메타데이터
+└── template/         # 실제 프로젝트 파일
+    ├── src/          # 소스 코드
+    ├── .aiwf/        # AIWF 설정
+    ├── package.json  # 의존성
+    └── README.md     # 프로젝트 문서
+```
+
+## 템플릿 커스터마이징
+
+템플릿의 플레이스홀더:
+- `{{projectName}}` - 프로젝트 이름
+- `{{description}}` - 프로젝트 설명
+- `{{author}}` - 작성자
+- `{{year}}` - 현재 연도
+- `{{createdAt}}` - 생성 시간
+
+## 캐시 관리
+
+템플릿은 오프라인 사용을 위해 캐시될 수 있습니다:
+
+```bash
+# 캐시 생성
+aiwf cache create
+
+# 캐시 확인
+aiwf cache check
+
+# 캐시 삭제
+aiwf cache clear
+```

package/.aiwf/templates/api-server/config.json

@@ -0,0 +1,64 @@
+{
+  "name": "api-server",
+  "displayName": "API 서버 (Node.js + Express)",
+  "description": "Express와 TypeScript로 구성된 RESTful API 서버 템플릿",
+  "type": "api-server",
+  "language": "typescript",
+  "framework": "express",
+  "features": [
+    "Express 4",
+    "TypeScript",
+    "JWT Authentication",
+    "Swagger Documentation",
+    "Database Ready",
+    "AIWF Integration",
+    "Error Handling",
+    "Request Validation"
+  ],
+  "structure": {
+    "src": "소스 코드",
+    "tests": "테스트 파일",
+    ".aiwf": "AIWF 설정 및 메타데이터",
+    "docs": "API 문서"
+  },
+  "dependencies": {
+    "express": "^4.18.2",
+    "cors": "^2.8.5",
+    "helmet": "^7.0.0",
+    "compression": "^1.7.4",
+    "dotenv": "^16.3.1",
+    "jsonwebtoken": "^9.0.1",
+    "bcryptjs": "^2.4.3",
+    "express-validator": "^7.0.1",
+    "swagger-jsdoc": "^6.2.8",
+    "swagger-ui-express": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.17",
+    "@types/node": "^20.0.0",
+    "@types/cors": "^2.8.13",
+    "@types/compression": "^1.7.2",
+    "@types/jsonwebtoken": "^9.0.2",
+    "@types/bcryptjs": "^2.4.2",
+    "@types/swagger-jsdoc": "^6.0.1",
+    "@types/swagger-ui-express": "^4.1.3",
+    "@typescript-eslint/eslint-plugin": "^5.60.0",
+    "@typescript-eslint/parser": "^5.60.0",
+    "typescript": "^5.1.0",
+    "ts-node": "^10.9.0",
+    "nodemon": "^3.0.0",
+    "eslint": "^8.43.0",
+    "jest": "^29.5.0",
+    "@types/jest": "^29.5.0",
+    "supertest": "^6.3.0",
+    "@types/supertest": "^2.0.12"
+  },
+  "scripts": {
+    "dev": "nodemon",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "test": "jest",
+    "lint": "eslint . --ext .ts",
+    "aiwf": "node .aiwf/scripts/cli.js"
+  }
+}

package/.aiwf/templates/api-server/template/.aiwf/config.json

@@ -0,0 +1,56 @@
+{
+  "project_name": "{{projectName}}",
+  "project_type": "api-server",
+  "framework": "express",
+  "language": "typescript",
+  "created_at": "{{createdAt}}",
+  "version": "0.0.1",
+  "features": {
+    "feature_ledger": {
+      "enabled": true,
+      "auto_track": true,
+      "git_integration": true,
+      "api_endpoints": true
+    },
+    "ai_persona": {
+      "enabled": true,
+      "default": "backend-engineer",
+      "available": [
+        "backend-engineer",
+        "api-architect",
+        "database-specialist",
+        "security-auditor",
+        "performance-optimizer"
+      ]
+    },
+    "context_compression": {
+      "enabled": true,
+      "level": "balanced",
+      "token_limit": 100000,
+      "cache_enabled": true
+    },
+    "api_documentation": {
+      "enabled": true,
+      "swagger": true,
+      "postman_sync": false
+    }
+  },
+  "structure": {
+    "src_dir": "src",
+    "test_dir": "tests",
+    "build_dir": "dist",
+    "docs_dir": "docs"
+  },
+  "conventions": {
+    "routing": "restful",
+    "authentication": "jwt",
+    "validation": "express-validator",
+    "testing": "jest",
+    "linting": "eslint",
+    "database": "prepared"
+  },
+  "scripts": {
+    "pre_commit": "npm run lint && npm test",
+    "post_feature": "npm run aiwf:feature update && npm run aiwf:api docs"
+  }
+}

package/.aiwf/templates/api-server/template/.aiwf/feature-ledger.json

@@ -0,0 +1,42 @@
+{
+  "version": "1.0.0",
+  "project": "{{projectName}}",
+  "created": "{{createdAt}}",
+  "features": [
+    {
+      "id": "F001",
+      "name": "API 서버 초기 설정",
+      "description": "Express + TypeScript 기반 RESTful API 서버 초기 설정",
+      "type": "setup",
+      "status": "completed",
+      "created_at": "{{createdAt}}",
+      "completed_at": "{{createdAt}}",
+      "components": [
+        "Express 서버 설정",
+        "TypeScript 설정",
+        "미들웨어 구성",
+        "에러 핸들링",
+        "API 문서화 (Swagger)"
+      ],
+      "endpoints": [
+        "GET /api/health",
+        "GET /api/v1/status",
+        "GET /docs"
+      ],
+      "files": [
+        "src/index.ts",
+        "src/app.ts",
+        "src/middleware/*",
+        "src/config/*"
+      ],
+      "tags": ["초기설정", "인프라", "API"]
+    }
+  ],
+  "statistics": {
+    "total_features": 1,
+    "completed": 1,
+    "in_progress": 0,
+    "planned": 0,
+    "total_endpoints": 3
+  }
+}

package/.aiwf/templates/api-server/template/.aiwf/personas/backend-engineer.json

@@ -0,0 +1,40 @@
+{
+  "id": "backend-engineer",
+  "name": "백엔드 엔지니어",
+  "description": "Express API 서버 개발 전문가",
+  "expertise": [
+    "RESTful API 설계",
+    "Express.js 최적화",
+    "데이터베이스 설계 및 쿼리 최적화",
+    "인증/인가 시스템",
+    "API 보안",
+    "성능 튜닝"
+  ],
+  "context": {
+    "focus_areas": [
+      "API 설계 패턴",
+      "에러 핸들링",
+      "입력 검증",
+      "미들웨어 아키텍처",
+      "데이터베이스 트랜잭션"
+    ],
+    "code_style": {
+      "naming": "camelCase (변수/함수), PascalCase (클래스/인터페이스)",
+      "structure": "계층형 아키텍처 (Controller-Service-Repository)",
+      "error_handling": "중앙집중식 에러 핸들러",
+      "validation": "DTO와 validation 미들웨어 사용"
+    },
+    "best_practices": [
+      "RESTful 원칙 준수",
+      "적절한 HTTP 상태 코드 사용",
+      "요청/응답 DTO 정의",
+      "비즈니스 로직과 컨트롤러 분리",
+      "트랜잭션 관리"
+    ]
+  },
+  "prompts": {
+    "api_design": "RESTful 원칙을 따르며 확장 가능하고 유지보수가 쉬운 API를 설계해주세요.",
+    "security": "OWASP Top 10을 고려하여 보안이 강화된 API를 구현해주세요.",
+    "performance": "캐싱, 쿼리 최적화, 비동기 처리를 활용하여 고성능 API를 만들어주세요."
+  }
+}