aiwf 0.3.0 → 0.3.2

package/claude-code/aiwf/ko/scripts/git-integration.cjs

@@ -0,0 +1,391 @@
+#!/usr/bin/env node
+
+const fs = require('fs').promises;
+const path = require('path');
+const { exec, execSync } = require('child_process');
+const util = require('util');
+const execAsync = util.promisify(exec);
+
+// AIWF 경로 설정
+const AIWF_ROOT = path.join(process.cwd(), '.aiwf');
+const FEATURE_LEDGERS_PATH = path.join(AIWF_ROOT, '06_FEATURE_LEDGERS');
+const ACTIVE_PATH = path.join(FEATURE_LEDGERS_PATH, 'active');
+
+// 커밋 메시지에서 Feature ID를 추출하는 정규식 패턴들
+const FEATURE_ID_PATTERNS = [
+    /FL\d{3}(?!\d)/,                    // FL001 (not followed by digit)
+    /\[FL\d{3}\]/,                      // [FL001]
+    /\(FL\d{3}\)/,                      // (FL001)
+    /(feat|fix|docs|style|refactor|test|chore)\(FL\d{3}\)/,  // feat(FL001)
+    /FL\d{3}:/,                         // FL001:
+    /#FL\d{3}/,                         // #FL001
+    /relates to FL\d{3}/i,              // relates to FL001
+];
+
+// Feature ID 추출 함수
+function extractFeatureId(text) {
+    for (const pattern of FEATURE_ID_PATTERNS) {
+        const match = text.match(pattern);
+        if (match) {
+            // 순수 Feature ID만 추출 (FL###)
+            const idMatch = match[0].match(/FL\d{3}/);
+            if (idMatch) {
+                return idMatch[0];
+            }
+        }
+    }
+    return null;
+}
+
+// Feature 파일 경로 가져오기
+async function getFeaturePath(featureId) {
+    // active 폴더에서 먼저 확인
+    const activePath = path.join(ACTIVE_PATH, `${featureId}_*.md`);
+    try {
+        const files = await fs.readdir(ACTIVE_PATH);
+        const featureFile = files.find(file => file.startsWith(`${featureId}_`));
+        if (featureFile) {
+            return path.join(ACTIVE_PATH, featureFile);
+        }
+    } catch (error) {
+        // active 폴더가 없거나 접근 불가
+    }
+
+    // completed 폴더 확인
+    const completedPath = path.join(FEATURE_LEDGERS_PATH, 'completed');
+    try {
+        const files = await fs.readdir(completedPath);
+        const featureFile = files.find(file => file.startsWith(`${featureId}_`));
+        if (featureFile) {
+            return path.join(completedPath, featureFile);
+        }
+    } catch (error) {
+        // completed 폴더가 없거나 접근 불가
+    }
+
+    return null;
+}
+
+// YAML frontmatter 파싱
+function parseYamlFrontmatter(content) {
+    const yamlMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!yamlMatch) return null;
+
+    const yamlContent = yamlMatch[1];
+    const lines = yamlContent.split('\n');
+    const metadata = {};
+
+    let currentKey = null;
+    let currentArray = null;
+    let inArray = false;
+
+    for (const line of lines) {
+        if (line.trim() === '') continue;
+
+        // 배열 항목 처리
+        if (line.startsWith('  - ')) {
+            if (currentArray) {
+                currentArray.push(line.substring(4).trim());
+            }
+            continue;
+        }
+
+        // 새로운 키 처리
+        const keyMatch = line.match(/^(\w+):\s*(.*)/);
+        if (keyMatch) {
+            currentKey = keyMatch[1];
+            const value = keyMatch[2].trim();
+
+            if (value.startsWith('[')) {
+                // 인라인 배열
+                metadata[currentKey] = value.slice(1, -1).split(',').map(v => v.trim());
+                currentArray = null;
+            } else if (value === '') {
+                // 다음 줄에 배열이 올 수 있음
+                metadata[currentKey] = [];
+                currentArray = metadata[currentKey];
+            } else {
+                // 일반 값
+                metadata[currentKey] = value;
+                currentArray = null;
+            }
+        }
+    }
+
+    return metadata;
+}
+
+// YAML frontmatter 업데이트
+function updateYamlFrontmatter(content, updates) {
+    const yamlMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!yamlMatch) return content;
+
+    const metadata = parseYamlFrontmatter(content);
+    if (!metadata) return content;
+
+    // 메타데이터 업데이트
+    Object.assign(metadata, updates);
+
+    // YAML 문자열 재구성
+    let yamlLines = ['---'];
+    
+    for (const [key, value] of Object.entries(metadata)) {
+        if (Array.isArray(value)) {
+            if (value.length === 0) {
+                yamlLines.push(`${key}: []`);
+            } else {
+                yamlLines.push(`${key}:`);
+                value.forEach(item => {
+                    yamlLines.push(`  - ${item}`);
+                });
+            }
+        } else if (typeof value === 'object' && value !== null) {
+            yamlLines.push(`${key}:`);
+            for (const [subKey, subValue] of Object.entries(value)) {
+                yamlLines.push(`  ${subKey}: ${subValue}`);
+            }
+        } else {
+            yamlLines.push(`${key}: ${value || ''}`);
+        }
+    }
+    
+    yamlLines.push('---');
+
+    // 본문과 결합
+    const bodyMatch = content.match(/^---\n[\s\S]*?\n---\n([\s\S]*)/);
+    const body = bodyMatch ? bodyMatch[1] : '';
+    
+    return yamlLines.join('\n') + '\n' + body;
+}
+
+// Git 커밋 정보 가져오기
+async function getCommitInfo(commitHash) {
+    try {
+        const { stdout } = await execAsync(
+            `git show --no-patch --format="%H|%s|%ae|%ai|%b" ${commitHash}`
+        );
+        
+        const [hash, subject, author, date, body] = stdout.trim().split('|');
+        
+        // 변경된 파일 수 가져오기
+        const { stdout: statsOutput } = await execAsync(
+            `git show --stat --format="" ${commitHash} | tail -1`
+        );
+        
+        let filesChanged = 0, insertions = 0, deletions = 0;
+        const statsMatch = statsOutput.match(/(\d+) files? changed/);
+        if (statsMatch) {
+            filesChanged = parseInt(statsMatch[1]);
+        }
+        const insertMatch = statsOutput.match(/(\d+) insertions?\(\+\)/);
+        if (insertMatch) {
+            insertions = parseInt(insertMatch[1]);
+        }
+        const deleteMatch = statsOutput.match(/(\d+) deletions?\(-\)/);
+        if (deleteMatch) {
+            deletions = parseInt(deleteMatch[1]);
+        }
+
+        return {
+            hash: hash.substring(0, 7), // 짧은 해시
+            message: subject,
+            author,
+            date: date.split(' ')[0] + ' ' + date.split(' ')[1], // YYYY-MM-DD HH:MM 형식
+            files_changed: filesChanged,
+            insertions,
+            deletions
+        };
+    } catch (error) {
+        console.error(`Error getting commit info: ${error.message}`);
+        return null;
+    }
+}
+
+// Feature에 커밋 링크
+async function linkCommitToFeature(featureId, commitInfo) {
+    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;
+        }
+
+        // git_commits 배열 초기화
+        if (!metadata.git_commits) {
+            metadata.git_commits = [];
+        }
+
+        // 이미 링크된 커밋인지 확인
+        const isLinked = metadata.git_commits.some(commit => 
+            typeof commit === 'string' ? commit === commitInfo.hash : commit.hash === commitInfo.hash
+        );
+
+        if (!isLinked) {
+            // 커밋 정보를 배열에 추가
+            metadata.git_commits.push(commitInfo.hash);
+        }
+
+        // 상태 업데이트
+        if (metadata.status === 'planned') {
+            metadata.status = 'active';
+        }
+
+        // 마지막 업데이트 시간
+        metadata.last_updated = new Date().toISOString().replace('T', ' ').substring(0, 16);
+
+        // 파일 업데이트
+        const updatedContent = updateYamlFrontmatter(content, metadata);
+        await fs.writeFile(featurePath, updatedContent);
+
+        console.log(`✓ Linked commit ${commitInfo.hash} to feature ${featureId}`);
+        return true;
+    } catch (error) {
+        console.error(`Error linking commit to feature: ${error.message}`);
+        return false;
+    }
+}
+
+// 현재 브랜치를 Feature에 링크
+async function linkBranchToFeature(featureId) {
+    try {
+        const { stdout: branchName } = await execAsync('git rev-parse --abbrev-ref HEAD');
+        const branch = branchName.trim();
+
+        const featurePath = await getFeaturePath(featureId);
+        if (!featurePath) {
+            console.error(`Feature ${featureId} not found`);
+            return false;
+        }
+
+        const content = await fs.readFile(featurePath, 'utf-8');
+        const metadata = parseYamlFrontmatter(content);
+
+        if (!metadata) {
+            console.error(`Invalid feature file format: ${featurePath}`);
+            return false;
+        }
+
+        metadata.git_branch = branch;
+        metadata.last_updated = new Date().toISOString().replace('T', ' ').substring(0, 16);
+
+        const updatedContent = updateYamlFrontmatter(content, metadata);
+        await fs.writeFile(featurePath, updatedContent);
+
+        console.log(`✓ Linked branch '${branch}' to feature ${featureId}`);
+        return true;
+    } catch (error) {
+        console.error(`Error linking branch to feature: ${error.message}`);
+        return false;
+    }
+}
+
+// 메인 함수
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+
+    switch (command) {
+        case 'pre-commit':
+            // Pre-commit hook 처리
+            try {
+                const { stdout: stagedFiles } = await execAsync('git diff --cached --name-only');
+                const files = stagedFiles.trim().split('\n').filter(f => f);
+                
+                for (const file of files) {
+                    try {
+                        const { stdout: content } = await execAsync(`git show :${file}`);
+                        const featureId = extractFeatureId(content);
+                        if (featureId) {
+                            console.log(`Found feature reference: ${featureId} in ${file}`);
+                            // Feature 활동 업데이트는 post-commit에서 처리
+                        }
+                    } catch (error) {
+                        // 파일 읽기 실패 무시
+                    }
+                }
+            } catch (error) {
+                console.error(`Pre-commit error: ${error.message}`);
+            }
+            break;
+
+        case 'post-commit':
+            // Post-commit hook 처리
+            try {
+                const { stdout: commitMessage } = await execAsync('git log -1 --pretty=%B');
+                const featureId = extractFeatureId(commitMessage);
+                
+                if (featureId) {
+                    const { stdout: commitHash } = await execAsync('git rev-parse HEAD');
+                    const commitInfo = await getCommitInfo(commitHash.trim());
+                    
+                    if (commitInfo) {
+                        await linkCommitToFeature(featureId, commitInfo);
+                    }
+                }
+            } catch (error) {
+                console.error(`Post-commit error: ${error.message}`);
+            }
+            break;
+
+        case 'link-commit':
+            // 수동 커밋 링크
+            const featureId = args[1];
+            const commitHash = args[2];
+            
+            if (!featureId || !commitHash) {
+                console.error('Usage: git-integration.js link-commit <feature-id> <commit-hash>');
+                process.exit(1);
+            }
+
+            const commitInfo = await getCommitInfo(commitHash);
+            if (commitInfo) {
+                await linkCommitToFeature(featureId, commitInfo);
+            }
+            break;
+
+        case 'link-branch':
+            // 현재 브랜치 링크
+            const branchFeatureId = args[1];
+            
+            if (!branchFeatureId) {
+                console.error('Usage: git-integration.js link-branch <feature-id>');
+                process.exit(1);
+            }
+
+            await linkBranchToFeature(branchFeatureId);
+            break;
+
+        default:
+            console.log('AIWF Git Integration');
+            console.log('Usage:');
+            console.log('  git-integration.js pre-commit');
+            console.log('  git-integration.js post-commit');
+            console.log('  git-integration.js link-commit <feature-id> <commit-hash>');
+            console.log('  git-integration.js link-branch <feature-id>');
+    }
+}
+
+// 스크립트 실행
+if (require.main === module) {
+    main().catch(error => {
+        console.error(`Fatal error: ${error.message}`);
+        process.exit(1);
+    });
+}
+
+module.exports = {
+    extractFeatureId,
+    getFeaturePath,
+    linkCommitToFeature,
+    linkBranchToFeature,
+    parseYamlFrontmatter,
+    updateYamlFrontmatter
+};

package/claude-code/aiwf/ko/scripts/install-git-hooks.cjs

@@ -0,0 +1,226 @@
+#!/usr/bin/env node
+
+const fs = require('fs').promises;
+const path = require('path');
+const { execSync } = require('child_process');
+
+// Git hooks 경로
+const GIT_HOOKS_PATH = path.join(process.cwd(), '.git', 'hooks');
+const SCRIPTS_PATH = path.join(process.cwd(), '.aiwf', 'scripts');
+
+// Hook 템플릿
+const PRE_COMMIT_HOOK = `#!/bin/sh
+# AIWF Feature-Git Integration Pre-commit Hook
+# 이 hook은 AIWF에 의해 자동으로 설치되었습니다.
+
+# 기존 pre-commit hook이 있으면 실행
+if [ -f .git/hooks/pre-commit.aiwf-backup ]; then
+    .git/hooks/pre-commit.aiwf-backup
+    if [ $? -ne 0 ]; then
+        exit 1
+    fi
+fi
+
+# AIWF Git 통합 실행
+node .aiwf/scripts/git-integration.cjs pre-commit
+
+exit 0
+`;
+
+const POST_COMMIT_HOOK = `#!/bin/sh
+# AIWF Feature-Git Integration Post-commit Hook
+# 이 hook은 AIWF에 의해 자동으로 설치되었습니다.
+
+# AIWF Git 통합 실행
+node .aiwf/scripts/git-integration.cjs post-commit
+
+# 기존 post-commit hook이 있으면 실행
+if [ -f .git/hooks/post-commit.aiwf-backup ]; then
+    .git/hooks/post-commit.aiwf-backup
+fi
+
+exit 0
+`;
+
+const POST_MERGE_HOOK = `#!/bin/sh
+# AIWF Feature-Git Integration Post-merge Hook
+# 이 hook은 AIWF에 의해 자동으로 설치되었습니다.
+
+# 현재 브랜치 확인
+branch_name=$(git rev-parse --abbrev-ref HEAD)
+
+# main 또는 master 브랜치로 머지된 경우
+if [ "$branch_name" = "main" ] || [ "$branch_name" = "master" ]; then
+    # 머지된 브랜치에서 Feature ID 추출
+    merge_commit=$(git rev-parse HEAD)
+    merge_message=$(git log -1 --pretty=%B $merge_commit)
+    
+    # Feature ID 추출 시도
+    feature_id=$(echo "$merge_message" | grep -o "FL[0-9]\\{3\\}" | head -1)
+    
+    if [ -n "$feature_id" ]; then
+        echo "Updating feature $feature_id status to completed..."
+        # Feature 상태 업데이트 명령 실행
+        node .aiwf/scripts/update-feature-status.cjs "$feature_id" "completed"
+    fi
+fi
+
+# 기존 post-merge hook이 있으면 실행
+if [ -f .git/hooks/post-merge.aiwf-backup ]; then
+    .git/hooks/post-merge.aiwf-backup
+fi
+
+exit 0
+`;
+
+// Hook 설치 함수
+async function installHook(hookName, hookContent) {
+    const hookPath = path.join(GIT_HOOKS_PATH, hookName);
+    
+    try {
+        // 기존 hook 백업
+        try {
+            await fs.access(hookPath);
+            const backupPath = `${hookPath}.aiwf-backup`;
+            
+            // 이미 백업이 있는지 확인
+            try {
+                await fs.access(backupPath);
+                console.log(`✓ Backup already exists for ${hookName}`);
+            } catch {
+                // 백업 생성
+                await fs.copyFile(hookPath, backupPath);
+                console.log(`✓ Backed up existing ${hookName} to ${hookName}.aiwf-backup`);
+            }
+        } catch {
+            // 기존 hook이 없음
+        }
+
+        // 새 hook 설치
+        await fs.writeFile(hookPath, hookContent);
+        await fs.chmod(hookPath, 0o755);
+        
+        console.log(`✓ Installed ${hookName} hook`);
+        return true;
+    } catch (error) {
+        console.error(`✗ Failed to install ${hookName}: ${error.message}`);
+        return false;
+    }
+}
+
+// Hook 제거 함수
+async function uninstallHook(hookName) {
+    const hookPath = path.join(GIT_HOOKS_PATH, hookName);
+    const backupPath = `${hookPath}.aiwf-backup`;
+    
+    try {
+        // 현재 hook 제거
+        await fs.unlink(hookPath);
+        
+        // 백업이 있으면 복원
+        try {
+            await fs.access(backupPath);
+            await fs.rename(backupPath, hookPath);
+            console.log(`✓ Restored original ${hookName} hook`);
+        } catch {
+            console.log(`✓ Removed ${hookName} hook`);
+        }
+        
+        return true;
+    } catch (error) {
+        console.error(`✗ Failed to uninstall ${hookName}: ${error.message}`);
+        return false;
+    }
+}
+
+// Git 저장소 확인
+async function checkGitRepository() {
+    try {
+        execSync('git rev-parse --git-dir', { stdio: 'ignore' });
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+// 메인 함수
+async function main() {
+    const command = process.argv[2] || 'install';
+
+    // Git 저장소 확인
+    if (!await checkGitRepository()) {
+        console.error('Error: Not in a Git repository');
+        process.exit(1);
+    }
+
+    // .git/hooks 디렉토리 확인 및 생성
+    try {
+        await fs.access(GIT_HOOKS_PATH);
+    } catch {
+        await fs.mkdir(GIT_HOOKS_PATH, { recursive: true });
+    }
+
+    switch (command) {
+        case 'install':
+            console.log('Installing AIWF Git hooks...\n');
+            
+            const preCommitSuccess = await installHook('pre-commit', PRE_COMMIT_HOOK);
+            const postCommitSuccess = await installHook('post-commit', POST_COMMIT_HOOK);
+            const postMergeSuccess = await installHook('post-merge', POST_MERGE_HOOK);
+            
+            if (preCommitSuccess && postCommitSuccess && postMergeSuccess) {
+                console.log('\n✓ All hooks installed successfully!');
+                console.log('\nThe following hooks are now active:');
+                console.log('  - pre-commit: Detects feature references in staged files');
+                console.log('  - post-commit: Links commits to features automatically');
+                console.log('  - post-merge: Updates feature status on merge to main');
+            } else {
+                console.log('\n⚠ Some hooks failed to install');
+            }
+            break;
+
+        case 'uninstall':
+            console.log('Uninstalling AIWF Git hooks...\n');
+            
+            await uninstallHook('pre-commit');
+            await uninstallHook('post-commit');
+            await uninstallHook('post-merge');
+            
+            console.log('\n✓ All hooks uninstalled');
+            break;
+
+        case 'status':
+            console.log('AIWF Git hooks status:\n');
+            
+            const hooks = ['pre-commit', 'post-commit', 'post-merge'];
+            for (const hook of hooks) {
+                const hookPath = path.join(GIT_HOOKS_PATH, hook);
+                try {
+                    const content = await fs.readFile(hookPath, 'utf-8');
+                    if (content.includes('AIWF Feature-Git Integration')) {
+                        console.log(`✓ ${hook}: AIWF hook installed`);
+                    } else {
+                        console.log(`○ ${hook}: Other hook installed`);
+                    }
+                } catch {
+                    console.log(`✗ ${hook}: Not installed`);
+                }
+            }
+            break;
+
+        default:
+            console.log('AIWF Git Hooks Installer');
+            console.log('\nUsage:');
+            console.log('  node install-git-hooks.js install    Install AIWF hooks');
+            console.log('  node install-git-hooks.js uninstall  Remove AIWF hooks');
+            console.log('  node install-git-hooks.js status     Check hooks status');
+    }
+}
+
+// 스크립트 실행
+if (require.main === module) {
+    main().catch(error => {
+        console.error(`Fatal error: ${error.message}`);
+        process.exit(1);
+    });
+}