aiwf 0.3.0 → 0.3.2

package/claude-code/aiwf/ko/scripts/cache-templates.js

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+
+const fs = require('fs-extra');
+const path = require('path');
+const https = require('https');
+const tar = require('tar');
+const chalk = require('chalk');
+const ora = require('ora');
+
+const CACHE_DIR = path.join(__dirname, '../.cache');
+const TEMPLATES_DIR = path.join(__dirname, '../templates');
+const DEPENDENCIES_CACHE = path.join(CACHE_DIR, 'dependencies');
+
+// 각 템플릿의 주요 의존성 목록
+const TEMPLATE_DEPENDENCIES = {
+  'web-app': [
+    'react@18',
+    'react-dom@18',
+    'vite@4',
+    'typescript@5',
+    'tailwindcss@3'
+  ],
+  'api-server': [
+    'express@4',
+    'typescript@5',
+    'jsonwebtoken@9',
+    'swagger-ui-express@5'
+  ],
+  'npm-library': [
+    'typescript@5',
+    'rollup@3',
+    'jest@29'
+  ]
+};
+
+async function cacheTemplates() {
+  console.log(chalk.cyan('\n📦 AIWF 템플릿 캐시 시스템\n'));
+
+  const spinner = ora('캐시 디렉토리 준비 중...').start();
+
+  try {
+    // 캐시 디렉토리 생성
+    await fs.ensureDir(CACHE_DIR);
+    await fs.ensureDir(DEPENDENCIES_CACHE);
+
+    spinner.text = '템플릿 압축 중...';
+
+    // 각 템플릿을 압축하여 캐시
+    const templates = await fs.readdir(TEMPLATES_DIR);
+    
+    for (const template of templates) {
+      const templatePath = path.join(TEMPLATES_DIR, template);
+      const stat = await fs.stat(templatePath);
+      
+      if (stat.isDirectory()) {
+        const cachePath = path.join(CACHE_DIR, `${template}.tar.gz`);
+        
+        await tar.create(
+          {
+            gzip: true,
+            file: cachePath,
+            cwd: TEMPLATES_DIR
+          },
+          [template]
+        );
+
+        spinner.text = `${template} 템플릿 캐시 완료`;
+      }
+    }
+
+    spinner.text = '템플릿 메타데이터 생성 중...';
+
+    // 캐시 메타데이터 생성
+    const metadata = {
+      version: require('../../package.json').version,
+      cachedAt: new Date().toISOString(),
+      templates: {},
+      dependencies: {}
+    };
+
+    for (const template of templates) {
+      const configPath = path.join(TEMPLATES_DIR, template, 'config.json');
+      if (await fs.pathExists(configPath)) {
+        const config = await fs.readJson(configPath);
+        metadata.templates[template] = {
+          name: config.name,
+          displayName: config.displayName,
+          description: config.description,
+          size: (await fs.stat(path.join(CACHE_DIR, `${template}.tar.gz`))).size
+        };
+      }
+    }
+
+    await fs.writeJson(path.join(CACHE_DIR, 'metadata.json'), metadata, { spaces: 2 });
+
+    spinner.succeed('템플릿 캐시 완료!');
+
+    // 캐시 통계 출력
+    console.log(chalk.green('\n✅ 캐시 생성 완료\n'));
+    console.log('캐시된 템플릿:');
+    for (const [template, info] of Object.entries(metadata.templates)) {
+      console.log(chalk.gray(`  - ${info.displayName}: ${(info.size / 1024).toFixed(2)} KB`));
+    }
+
+    const totalSize = Object.values(metadata.templates)
+      .reduce((sum, info) => sum + info.size, 0);
+    console.log(chalk.gray(`\n총 캐시 크기: ${(totalSize / 1024 / 1024).toFixed(2)} MB`));
+
+  } catch (error) {
+    spinner.fail('캐시 생성 중 오류가 발생했습니다.');
+    console.error(chalk.red(error.message));
+    process.exit(1);
+  }
+}
+
+async function restoreFromCache(templateName, targetPath) {
+  const cachePath = path.join(CACHE_DIR, `${templateName}.tar.gz`);
+  
+  if (!await fs.pathExists(cachePath)) {
+    throw new Error(`캐시된 템플릿을 찾을 수 없습니다: ${templateName}`);
+  }
+
+  await tar.extract({
+    file: cachePath,
+    cwd: targetPath
+  });
+
+  // 템플릿 내용을 상위 디렉토리로 이동
+  const extractedPath = path.join(targetPath, templateName, 'template');
+  const files = await fs.readdir(extractedPath);
+  
+  for (const file of files) {
+    await fs.move(
+      path.join(extractedPath, file),
+      path.join(targetPath, file)
+    );
+  }
+
+  // 임시 디렉토리 삭제
+  await fs.remove(path.join(targetPath, templateName));
+}
+
+async function checkCache() {
+  const metadataPath = path.join(CACHE_DIR, 'metadata.json');
+  
+  if (!await fs.pathExists(metadataPath)) {
+    return { valid: false, reason: '캐시가 존재하지 않습니다' };
+  }
+
+  const metadata = await fs.readJson(metadataPath);
+  const packageVersion = require('../../package.json').version;
+
+  if (metadata.version !== packageVersion) {
+    return { valid: false, reason: '버전이 일치하지 않습니다' };
+  }
+
+  // 캐시가 7일 이상 오래된 경우
+  const cacheAge = Date.now() - new Date(metadata.cachedAt).getTime();
+  const sevenDays = 7 * 24 * 60 * 60 * 1000;
+  
+  if (cacheAge > sevenDays) {
+    return { valid: false, reason: '캐시가 오래되었습니다' };
+  }
+
+  return { valid: true, metadata };
+}
+
+// CLI 명령어 처리
+if (require.main === module) {
+  const command = process.argv[2];
+
+  switch (command) {
+    case 'create':
+      cacheTemplates().catch(error => {
+        console.error(chalk.red('오류:', error.message));
+        process.exit(1);
+      });
+      break;
+
+    case 'check':
+      checkCache().then(result => {
+        if (result.valid) {
+          console.log(chalk.green('✅ 캐시가 유효합니다'));
+          console.log(chalk.gray(`생성일: ${result.metadata.cachedAt}`));
+        } else {
+          console.log(chalk.yellow(`⚠️  ${result.reason}`));
+        }
+      });
+      break;
+
+    case 'clear':
+      fs.remove(CACHE_DIR).then(() => {
+        console.log(chalk.green('✅ 캐시가 삭제되었습니다'));
+      });
+      break;
+
+    default:
+      console.log(`
+사용법: node cache-templates.js [command]
+
+명령어:
+  create  템플릿 캐시 생성
+  check   캐시 상태 확인
+  clear   캐시 삭제
+`);
+  }
+}
+
+module.exports = { cacheTemplates, restoreFromCache, checkCache };

package/claude-code/aiwf/ko/scripts/create-offline.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const ora = require('ora');
+const { checkCache, restoreFromCache } = require('./cache-templates');
+
+async function createProjectOffline(template, projectName, targetDir) {
+  const spinner = ora('오프라인 모드로 프로젝트 생성 중...').start();
+
+  try {
+    // 캐시 확인
+    const cacheStatus = await checkCache();
+    
+    if (!cacheStatus.valid) {
+      spinner.fail(`캐시 문제: ${cacheStatus.reason}`);
+      console.log(chalk.yellow('\n온라인 모드로 전환하거나 캐시를 업데이트하세요.'));
+      return false;
+    }
+
+    spinner.text = '캐시에서 템플릿 복원 중...';
+
+    // 캐시에서 템플릿 복원
+    await restoreFromCache(template, targetDir);
+
+    // 플레이스홀더 교체
+    const replacements = {
+      '{{projectName}}': projectName,
+      '{{createdAt}}': new Date().toISOString(),
+      '{{year}}': new Date().getFullYear().toString()
+    };
+
+    await replacePlaceholders(targetDir, replacements);
+
+    spinner.succeed('프로젝트가 오프라인 모드로 생성되었습니다!');
+
+    console.log(chalk.green(`\n✅ ${projectName} 프로젝트가 생성되었습니다!\n`));
+    console.log(chalk.yellow('⚠️  오프라인 모드로 생성되었습니다.'));
+    console.log('인터넷 연결 후 다음 명령어를 실행하세요:\n');
+    console.log(chalk.cyan(`  cd ${targetDir}`));
+    console.log(chalk.cyan('  npm install\n'));
+
+    return true;
+
+  } catch (error) {
+    spinner.fail('오프라인 프로젝트 생성 실패');
+    throw error;
+  }
+}
+
+async function replacePlaceholders(dir, replacements) {
+  const files = await fs.readdir(dir);
+
+  for (const file of files) {
+    const filePath = path.join(dir, file);
+    const stat = await fs.stat(filePath);
+
+    if (stat.isDirectory() && file !== 'node_modules') {
+      await replacePlaceholders(filePath, replacements);
+    } else if (stat.isFile() && !file.endsWith('.jpg') && !file.endsWith('.png')) {
+      try {
+        let content = await fs.readFile(filePath, 'utf8');
+        
+        for (const [placeholder, value] of Object.entries(replacements)) {
+          content = content.replace(new RegExp(placeholder, 'g'), value);
+        }
+
+        await fs.writeFile(filePath, content, 'utf8');
+      } catch (error) {
+        // 바이너리 파일 무시
+      }
+    }
+  }
+}
+
+// 네트워크 연결 확인
+function isOnline() {
+  return new Promise((resolve) => {
+    require('dns').lookup('registry.npmjs.org', (err) => {
+      resolve(!err);
+    });
+  });
+}
+
+module.exports = { createProjectOffline, isOnline };

package/claude-code/aiwf/ko/scripts/create-project.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+
+const fs = require('fs-extra');
+const path = require('path');
+const prompts = require('prompts');
+const chalk = require('chalk');
+const ora = require('ora');
+
+const TEMPLATES_DIR = path.join(__dirname, '../templates');
+
+async function createProject() {
+  console.log(chalk.cyan('\n🚀 AIWF 프로젝트 생성기\n'));
+
+  // 사용 가능한 템플릿 찾기
+  const templates = fs.readdirSync(TEMPLATES_DIR)
+    .filter(dir => fs.existsSync(path.join(TEMPLATES_DIR, dir, 'config.json')));
+
+  const templateConfigs = templates.map(template => {
+    const config = JSON.parse(
+      fs.readFileSync(path.join(TEMPLATES_DIR, template, 'config.json'), 'utf8')
+    );
+    return {
+      value: template,
+      title: config.displayName,
+      description: config.description
+    };
+  });
+
+  const questions = [
+    {
+      type: 'select',
+      name: 'template',
+      message: '템플릿을 선택하세요',
+      choices: templateConfigs,
+    },
+    {
+      type: 'text',
+      name: 'projectName',
+      message: '프로젝트 이름',
+      validate: value => {
+        if (!value) return '프로젝트 이름을 입력하세요';
+        if (!/^[a-z0-9-]+$/.test(value)) {
+          return '소문자, 숫자, 하이픈만 사용 가능합니다';
+        }
+        return true;
+      }
+    },
+    {
+      type: prev => prev === 'npm-library' ? 'text' : null,
+      name: 'description',
+      message: '프로젝트 설명',
+      initial: 'A new AIWF project'
+    },
+    {
+      type: prev => prev === 'npm-library' ? 'text' : null,
+      name: 'author',
+      message: '작성자',
+      initial: ''
+    },
+    {
+      type: 'text',
+      name: 'directory',
+      message: '프로젝트 디렉토리',
+      initial: prev => prev.projectName,
+      validate: value => {
+        if (!value) return '디렉토리를 입력하세요';
+        if (fs.existsSync(value)) {
+          return '이미 존재하는 디렉토리입니다';
+        }
+        return true;
+      }
+    }
+  ];
+
+  const answers = await prompts(questions);
+
+  if (!answers.template || !answers.projectName) {
+    console.log(chalk.red('\n❌ 프로젝트 생성이 취소되었습니다.'));
+    return;
+  }
+
+  const spinner = ora('프로젝트 생성 중...').start();
+
+  try {
+    const templatePath = path.join(TEMPLATES_DIR, answers.template, 'template');
+    const targetPath = path.resolve(answers.directory);
+
+    // 템플릿 복사
+    await fs.copy(templatePath, targetPath);
+
+    // 플레이스홀더 교체
+    const replacements = {
+      '{{projectName}}': answers.projectName,
+      '{{description}}': answers.description || '',
+      '{{author}}': answers.author || '',
+      '{{year}}': new Date().getFullYear().toString(),
+      '{{createdAt}}': new Date().toISOString(),
+      '{{username}}': answers.author?.toLowerCase().replace(/\s+/g, '') || 'username'
+    };
+
+    // 모든 파일에서 플레이스홀더 교체
+    await replacePlaceholders(targetPath, replacements);
+
+    spinner.succeed('프로젝트가 성공적으로 생성되었습니다!');
+
+    console.log(chalk.green(`\n✅ ${answers.projectName} 프로젝트가 생성되었습니다!\n`));
+    console.log('다음 명령어로 시작하세요:\n');
+    console.log(chalk.cyan(`  cd ${answers.directory}`));
+    console.log(chalk.cyan('  npm install'));
+    console.log(chalk.cyan('  npm run dev\n'));
+    console.log('AIWF 명령어:');
+    console.log(chalk.gray('  npm run aiwf status   # 프로젝트 상태 확인'));
+    console.log(chalk.gray('  npm run aiwf feature  # Feature Ledger 관리\n'));
+
+  } catch (error) {
+    spinner.fail('프로젝트 생성 중 오류가 발생했습니다.');
+    console.error(chalk.red(error.message));
+    process.exit(1);
+  }
+}
+
+async function replacePlaceholders(dir, replacements) {
+  const files = await fs.readdir(dir);
+
+  for (const file of files) {
+    const filePath = path.join(dir, file);
+    const stat = await fs.stat(filePath);
+
+    if (stat.isDirectory()) {
+      await replacePlaceholders(filePath, replacements);
+    } else if (stat.isFile()) {
+      let content = await fs.readFile(filePath, 'utf8');
+      
+      for (const [placeholder, value] of Object.entries(replacements)) {
+        content = content.replace(new RegExp(placeholder, 'g'), value);
+      }
+
+      await fs.writeFile(filePath, content, 'utf8');
+    }
+  }
+}
+
+// CLI 실행
+if (require.main === module) {
+  createProject().catch(error => {
+    console.error(chalk.red('오류:', error.message));
+    process.exit(1);
+  });
+}
+
+module.exports = { createProject };

package/claude-code/aiwf/ko/scripts/feature-progress-calculator.cjs

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+
+const fs = require('fs').promises;
+const path = require('path');
+const { parseYamlFrontmatter, updateYamlFrontmatter, getFeaturePath } = require('./git-integration.cjs');
+
+// 진행률 계산 알고리즘
+class ProgressCalculator {
+    constructor(metadata) {
+        this.metadata = metadata;
+        this.weights = {
+            checklist: 0.4,    // 40%
+            tasks: 0.4,        // 40%
+            time: 0.2          // 20%
+        };
+    }
+
+    // 전체 진행률 계산
+    calculate() {
+        let totalProgress = 0;
+        let validWeights = 0;
+
+        // 체크리스트 진행률
+        const checklistProgress = this.calculateChecklistProgress();
+        if (checklistProgress !== null) {
+            totalProgress += checklistProgress * this.weights.checklist;
+            validWeights += this.weights.checklist;
+        }
+
+        // 태스크 진행률
+        const taskProgress = this.calculateTaskProgress();
+        if (taskProgress !== null) {
+            totalProgress += taskProgress * this.weights.tasks;
+            validWeights += this.weights.tasks;
+        }
+
+        // 시간 기반 진행률
+        const timeProgress = this.calculateTimeProgress();
+        if (timeProgress !== null) {
+            totalProgress += timeProgress * this.weights.time;
+            validWeights += this.weights.time;
+        }
+
+        // 가중치 정규화
+        if (validWeights > 0) {
+            totalProgress = totalProgress / validWeights;
+        }
+
+        // 상태별 보정
+        if (this.metadata.status === 'completed') {
+            totalProgress = 1.0;
+        } else if (this.metadata.status === 'planned' && totalProgress === 0) {
+            totalProgress = 0.05; // 최소 5%
+        }
+
+        return Math.round(totalProgress * 100);
+    }
+
+    // 체크리스트 진행률 계산
+    calculateChecklistProgress() {
+        const total = this.metadata.checklist_items_total || 0;
+        const completed = this.metadata.checklist_items_completed || 0;
+        
+        if (total === 0) return null;
+        
+        return completed / total;
+    }
+
+    // 태스크 진행률 계산 (간소화된 버전)
+    calculateTaskProgress() {
+        const tasks = this.metadata.tasks || [];
+        if (tasks.length === 0) return null;
+
+        // 실제로는 각 태스크의 상태를 확인해야 하지만,
+        // 여기서는 커밋 수와 태스크 수의 비율로 추정
+        const commits = this.metadata.git_commits || [];
+        const commitsPerTask = 3; // 태스크당 평균 커밋 수 가정
+        
+        const estimatedProgress = commits.length / (tasks.length * commitsPerTask);
+        return Math.min(estimatedProgress, 1.0);
+    }
+
+    // 시간 기반 진행률 계산
+    calculateTimeProgress() {
+        const created = this.metadata.created_date;
+        const estimated = this.metadata.estimated_completion;
+        
+        if (!created || !estimated) return null;
+
+        const createdDate = new Date(created);
+        const estimatedDate = new Date(estimated);
+        const now = new Date();
+
+        // 전체 기간 (일 단위)
+        const totalDays = (estimatedDate - createdDate) / (1000 * 60 * 60 * 24);
+        if (totalDays <= 0) return null;
+
+        // 경과 기간
+        const elapsedDays = (now - createdDate) / (1000 * 60 * 60 * 24);
+        
+        // 진행률 (최대 100%)
+        return Math.min(elapsedDays / totalDays, 1.0);
+    }
+
+    // 상세 진행률 리포트
+    getDetailedReport() {
+        const checklistProgress = this.calculateChecklistProgress();
+        const taskProgress = this.calculateTaskProgress();
+        const timeProgress = this.calculateTimeProgress();
+        const totalProgress = this.calculate();
+
+        return {
+            total: totalProgress,
+            components: {
+                checklist: checklistProgress !== null ? Math.round(checklistProgress * 100) : null,
+                tasks: taskProgress !== null ? Math.round(taskProgress * 100) : null,
+                time: timeProgress !== null ? Math.round(timeProgress * 100) : null
+            },
+            metadata: {
+                status: this.metadata.status,
+                commits: (this.metadata.git_commits || []).length,
+                checklist: `${this.metadata.checklist_items_completed || 0}/${this.metadata.checklist_items_total || 0}`,
+                tasks: (this.metadata.tasks || []).length
+            }
+        };
+    }
+}
+
+// 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;
+        }
+
+        // 진행률 계산
+        const calculator = new ProgressCalculator(metadata);
+        const progress = calculator.calculate();
+        const report = calculator.getDetailedReport();
+
+        // 메타데이터 업데이트
+        metadata.progress_percentage = progress;
+        metadata.last_updated = new Date().toISOString().replace('T', ' ').substring(0, 16);
+
+        // 파일 업데이트
+        const updatedContent = updateYamlFrontmatter(content, metadata);
+        await fs.writeFile(featurePath, updatedContent);
+
+        // 리포트 출력
+        console.log(`Feature ${featureId} Progress Report`);
+        console.log('================================');
+        console.log(`Total Progress: ${report.total}%`);
+        console.log('\nComponent Breakdown:');
+        if (report.components.checklist !== null) {
+            console.log(`  - Checklist: ${report.components.checklist}% (${report.metadata.checklist})`);
+        }
+        if (report.components.tasks !== null) {
+            console.log(`  - Tasks: ${report.components.tasks}% (${report.metadata.tasks} tasks)`);
+        }
+        if (report.components.time !== null) {
+            console.log(`  - Time: ${report.components.time}%`);
+        }
+        console.log(`\nStatus: ${report.metadata.status}`);
+        console.log(`Commits: ${report.metadata.commits}`);
+
+        return true;
+    } catch (error) {
+        console.error(`Error updating feature progress: ${error.message}`);
+        return false;
+    }
+}
+
+// 모든 active feature의 진행률 업데이트
+async function updateAllFeaturesProgress() {
+    const activePath = path.join(process.cwd(), '.aiwf', '06_FEATURE_LEDGERS', 'active');
+    
+    try {
+        const files = await fs.readdir(activePath);
+        const featureFiles = files.filter(file => file.match(/^FL\d{3}_.*\.md$/));
+        
+        console.log(`Updating progress for ${featureFiles.length} active features...\n`);
+        
+        for (const file of featureFiles) {
+            const featureId = file.match(/^(FL\d{3})/)[1];
+            await updateFeatureProgress(featureId);
+            console.log('\n');
+        }
+        
+        console.log('All features updated successfully!');
+    } catch (error) {
+        console.error(`Error updating all features: ${error.message}`);
+    }
+}
+
+// 메인 함수
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+
+    if (!command) {
+        console.log('Feature Progress Calculator');
+        console.log('\nUsage:');
+        console.log('  node feature-progress-calculator.cjs <feature-id>    Update specific feature');
+        console.log('  node feature-progress-calculator.cjs --all           Update all active features');
+        process.exit(0);
+    }
+
+    if (command === '--all') {
+        await updateAllFeaturesProgress();
+    } else {
+        await updateFeatureProgress(command);
+    }
+}
+
+// 스크립트 실행
+if (require.main === module) {
+    main().catch(error => {
+        console.error(`Fatal error: ${error.message}`);
+        process.exit(1);
+    });
+}
+
+module.exports = {
+    ProgressCalculator,
+    updateFeatureProgress
+};