aiwf 0.3.7 → 0.3.12

package/src/utils/engineering-guard.js

@@ -0,0 +1,389 @@
+/**
+ * 오버엔지니어링 방지 가드
+ * YOLO 모드에서 과도한 복잡성을 방지하는 유틸리티
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import yaml from 'js-yaml';
+
+export class EngineeringGuard {
+  constructor(configPath = null) {
+    this.config = null;
+    this.violations = [];
+    this.warnings = [];
+    
+    if (configPath) {
+      this.loadConfig(configPath);
+    }
+  }
+
+  /**
+   * 설정 파일 로드
+   */
+  async loadConfig(configPath) {
+    try {
+      const content = await fs.readFile(configPath, 'utf-8');
+      const yoloConfig = yaml.load(content);
+      this.config = yoloConfig.overengineering_prevention || {};
+    } catch (error) {
+      // 기본 설정 사용
+      this.config = {
+        max_file_lines: 300,
+        max_function_lines: 50,
+        max_nesting_depth: 4,
+        max_abstraction_layers: 3,
+        limit_design_patterns: true,
+        no_future_proofing: true
+      };
+    }
+  }
+
+  /**
+   * 파일 복잡도 검사
+   */
+  async checkFileComplexity(filePath) {
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
+      const lines = content.split('\n');
+      
+      // 파일 크기 검사
+      if (lines.length > this.config.max_file_lines) {
+        this.violations.push({
+          type: 'file_too_large',
+          file: filePath,
+          lines: lines.length,
+          limit: this.config.max_file_lines,
+          severity: 'high'
+        });
+      }
+      
+      // 함수 크기 검사 (간단한 휴리스틱)
+      const functions = this.extractFunctions(content);
+      for (const func of functions) {
+        if (func.lines > this.config.max_function_lines) {
+          this.violations.push({
+            type: 'function_too_large',
+            file: filePath,
+            function: func.name,
+            lines: func.lines,
+            limit: this.config.max_function_lines,
+            severity: 'medium'
+          });
+        }
+      }
+      
+      // 중첩 깊이 검사
+      const maxNesting = this.calculateMaxNesting(content);
+      if (maxNesting > this.config.max_nesting_depth) {
+        this.violations.push({
+          type: 'excessive_nesting',
+          file: filePath,
+          depth: maxNesting,
+          limit: this.config.max_nesting_depth,
+          severity: 'medium'
+        });
+      }
+      
+      // 디자인 패턴 과용 검사
+      if (this.config.limit_design_patterns) {
+        const patterns = this.detectDesignPatterns(content);
+        if (patterns.length > 2) {
+          this.warnings.push({
+            type: 'too_many_patterns',
+            file: filePath,
+            patterns: patterns,
+            message: '단순한 해결책을 고려하세요'
+          });
+        }
+      }
+      
+      // 미래 대비 코드 검사
+      if (this.config.no_future_proofing) {
+        const futureProofing = this.detectFutureProofing(content);
+        if (futureProofing.length > 0) {
+          this.warnings.push({
+            type: 'future_proofing',
+            file: filePath,
+            instances: futureProofing,
+            message: 'YAGNI (You Ain\'t Gonna Need It) 원칙을 따르세요'
+          });
+        }
+      }
+      
+    } catch (error) {
+      // 파일 읽기 실패는 무시
+    }
+  }
+
+  /**
+   * 함수 추출 (간단한 패턴 매칭)
+   */
+  extractFunctions(content) {
+    const functions = [];
+    const lines = content.split('\n');
+    
+    // JavaScript/TypeScript 함수 패턴
+    const functionPatterns = [
+      /^(?:export\s+)?(?:async\s+)?function\s+(\w+)/,
+      /^(?:export\s+)?const\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[^=]+)\s*=>/,
+      /^\s*(\w+)\s*\([^)]*\)\s*\{/,
+      /^\s*(?:async\s+)?(\w+)\s*:\s*(?:async\s+)?(?:\([^)]*\)|[^=]+)\s*=>/
+    ];
+    
+    let currentFunction = null;
+    let braceCount = 0;
+    
+    lines.forEach((line, index) => {
+      // 함수 시작 감지
+      if (!currentFunction) {
+        for (const pattern of functionPatterns) {
+          const match = line.match(pattern);
+          if (match) {
+            currentFunction = {
+              name: match[1],
+              startLine: index,
+              lines: 0
+            };
+            braceCount = 0;
+            break;
+          }
+        }
+      }
+      
+      // 중괄호 카운트
+      if (currentFunction) {
+        braceCount += (line.match(/\{/g) || []).length;
+        braceCount -= (line.match(/\}/g) || []).length;
+        
+        // 함수 끝 감지
+        if (braceCount === 0 && line.includes('}')) {
+          currentFunction.lines = index - currentFunction.startLine + 1;
+          functions.push(currentFunction);
+          currentFunction = null;
+        }
+      }
+    });
+    
+    return functions;
+  }
+
+  /**
+   * 최대 중첩 깊이 계산
+   */
+  calculateMaxNesting(content) {
+    const lines = content.split('\n');
+    let maxDepth = 0;
+    let currentDepth = 0;
+    
+    lines.forEach(line => {
+      // 들여쓰기 기반 간단한 계산
+      const indent = line.match(/^(\s*)/)[1].length;
+      const depth = Math.floor(indent / 2); // 2 spaces = 1 level
+      
+      // 중괄호 기반 계산도 추가
+      currentDepth += (line.match(/\{/g) || []).length;
+      currentDepth -= (line.match(/\}/g) || []).length;
+      
+      maxDepth = Math.max(maxDepth, Math.max(depth, currentDepth));
+    });
+    
+    return maxDepth;
+  }
+
+  /**
+   * 디자인 패턴 감지
+   */
+  detectDesignPatterns(content) {
+    const patterns = [];
+    
+    // 일반적인 패턴 키워드
+    const patternKeywords = {
+      'Factory': /class\s+\w*Factory|createFactory|factory\s*:/i,
+      'Singleton': /getInstance|singleton|private\s+constructor/i,
+      'Observer': /subscribe|unsubscribe|notify|observer|listeners/i,
+      'Strategy': /strategy|setStrategy|executeStrategy/i,
+      'Decorator': /decorator|@\w+|wrapped|enhance/i,
+      'Adapter': /adapter|adapt|wrapper/i,
+      'Proxy': /proxy|handler|intercept/i
+    };
+    
+    for (const [pattern, regex] of Object.entries(patternKeywords)) {
+      if (regex.test(content)) {
+        patterns.push(pattern);
+      }
+    }
+    
+    return patterns;
+  }
+
+  /**
+   * 미래 대비 코드 감지
+   */
+  detectFutureProofing(content) {
+    const instances = [];
+    
+    // 미래 대비 코드 패턴
+    const futurePatterns = [
+      { pattern: /TODO:?\s*(?:future|later|someday|eventually)/gi, type: 'future_todo' },
+      { pattern: /FIXME:?\s*(?:when|if|after)/gi, type: 'conditional_fixme' },
+      { pattern: /\/\/\s*(?:Will|Might|Could)\s+(?:be|need|require)/gi, type: 'speculative_comment' },
+      { pattern: /reserved|future[Uu]se|placeholder|notImplemented/g, type: 'reserved_code' },
+      { pattern: /version\s*[><=]+\s*['"]?\d+\.\d+/g, type: 'version_check' },
+      { pattern: /deprecated.*future/gi, type: 'future_deprecation' }
+    ];
+    
+    const lines = content.split('\n');
+    lines.forEach((line, index) => {
+      for (const { pattern, type } of futurePatterns) {
+        const matches = line.match(pattern);
+        if (matches) {
+          instances.push({
+            type,
+            line: index + 1,
+            content: line.trim(),
+            matches
+          });
+        }
+      }
+    });
+    
+    return instances;
+  }
+
+  /**
+   * 프로젝트 전체 검사
+   */
+  async checkProject(projectPath, filePatterns = ['**/*.js', '**/*.ts', '**/*.jsx', '**/*.tsx']) {
+    this.violations = [];
+    this.warnings = [];
+    
+    // 간단한 파일 목록 수집 (실제로는 glob 패턴 사용 필요)
+    const checkDir = async (dir) => {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        
+        if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
+          await checkDir(fullPath);
+        } else if (entry.isFile()) {
+          const ext = path.extname(entry.name);
+          if (['.js', '.ts', '.jsx', '.tsx'].includes(ext)) {
+            await this.checkFileComplexity(fullPath);
+          }
+        }
+      }
+    };
+    
+    await checkDir(projectPath);
+    
+    return this.generateReport();
+  }
+
+  /**
+   * 검사 결과 리포트 생성
+   */
+  generateReport() {
+    const report = {
+      passed: this.violations.length === 0,
+      violations: this.violations,
+      warnings: this.warnings,
+      summary: {
+        total_violations: this.violations.length,
+        high_severity: this.violations.filter(v => v.severity === 'high').length,
+        medium_severity: this.violations.filter(v => v.severity === 'medium').length,
+        warnings: this.warnings.length
+      },
+      recommendations: []
+    };
+    
+    // 권장사항 생성
+    if (report.summary.high_severity > 0) {
+      report.recommendations.push('큰 파일을 작은 모듈로 분할하세요');
+    }
+    
+    if (this.violations.some(v => v.type === 'function_too_large')) {
+      report.recommendations.push('긴 함수를 더 작은 단위로 리팩토링하세요');
+    }
+    
+    if (this.violations.some(v => v.type === 'excessive_nesting')) {
+      report.recommendations.push('조기 반환(early return)을 사용하여 중첩을 줄이세요');
+    }
+    
+    if (this.warnings.some(w => w.type === 'too_many_patterns')) {
+      report.recommendations.push('필요한 경우가 아니면 단순한 해결책을 선택하세요');
+    }
+    
+    if (this.warnings.some(w => w.type === 'future_proofing')) {
+      report.recommendations.push('현재 요구사항에만 집중하세요 (YAGNI)');
+    }
+    
+    return report;
+  }
+
+  /**
+   * 실시간 피드백 제공
+   */
+  async provideFeedback(filePath, content = null) {
+    if (!content) {
+      content = await fs.readFile(filePath, 'utf-8');
+    }
+    
+    const feedback = [];
+    const lines = content.split('\n');
+    
+    // 즉각적인 피드백 규칙
+    if (lines.length > this.config.max_file_lines * 0.8) {
+      feedback.push({
+        level: 'warning',
+        message: `파일이 너무 커지고 있습니다 (${lines.length}/${this.config.max_file_lines} 줄). 분할을 고려하세요.`
+      });
+    }
+    
+    // 복잡한 조건문 감지
+    const complexConditions = content.match(/if\s*\([^)]{50,}\)/g);
+    if (complexConditions && complexConditions.length > 0) {
+      feedback.push({
+        level: 'suggestion',
+        message: '복잡한 조건문을 별도의 함수로 추출하는 것을 고려하세요.'
+      });
+    }
+    
+    // 과도한 주석 감지
+    const commentLines = lines.filter(line => line.trim().startsWith('//')).length;
+    const codeLines = lines.filter(line => line.trim() && !line.trim().startsWith('//')).length;
+    if (commentLines > codeLines * 0.5) {
+      feedback.push({
+        level: 'info',
+        message: '코드보다 주석이 많습니다. 코드 자체가 문서가 되도록 리팩토링을 고려하세요.'
+      });
+    }
+    
+    return feedback;
+  }
+}
+
+// 싱글톤 인스턴스
+let guardInstance = null;
+
+/**
+ * EngineeringGuard 인스턴스 가져오기
+ */
+export function getEngineeringGuard(configPath = null) {
+  if (!guardInstance) {
+    guardInstance = new EngineeringGuard(configPath);
+  }
+  return guardInstance;
+}
+
+/**
+ * 빠른 검사 헬퍼 함수
+ */
+export async function quickCheck(filePath) {
+  const guard = getEngineeringGuard();
+  await guard.checkFileComplexity(filePath);
+  return guard.generateReport();
+}
+
+export default EngineeringGuard;

package/.aiwf/00_PROJECT_MANIFEST.md

@@ -1,196 +0,0 @@
-# AIWF 프로젝트 매니페스트
-
-**프로젝트명**: AIWF (AI Workflow Framework)  
-**생성일**: 2025-07-02  
-**마지막 업데이트**: 2025-07-16  
-**프로젝트 유형**: Node.js NPM 패키지  
-**현재 버전**: 0.3.1
-**최고 마일스톤**: M03
-**최고 스프린트**: S03
-
-## 프로젝트 개요
-
-AIWF는 Claude Code와의 통합을 위해 설계된 마크다운 기반 프로젝트 관리 프레임워크입니다. AI 지원 개발을 위한 체계적인 워크플로우를 제공하며, 다국어 지원(한국어/영어)을 통해 글로벌 개발자들이 사용할 수 있도록 설계되었습니다.
-
-## 현재 마일스톤
-
-- **활성 마일스톤**: M02_Context_Engineering_Enhancement
-- **마일스톤 상태**: 완료
-- **진행률**: 100%
-- **완료일**: 2025-07-08
-
-## 현재 스프린트
-
-- **활성 스프린트**: S03_M02_ecosystem_integration
-- **스프린트 상태**: complete
-- **시작일**: 2025-07-08
-- **완료일**: 2025-07-08
-
-## 활성 태스크
-
-### 진행 중
-
-- **T14_S03**: 기본 프로젝트 템플릿 구축 (in_progress → 2025-07-10 06:20 시작)
-### 계획됨
-
-- 계획된 태스크 없음
-
-### 최근 완료
-
-- **T13_S03**: AI 도구 통합 템플릿 개발 (completed → 2025-07-10 04:37 완료)
-
-- **TX001**: Complete English Translation for 100% i18n Support (completed → 2025-07-09 08:13 완료)
-- **TX05_S02**: S02 통합 테스트 및 문서화 (completed → 2025-07-08 00:09 완료)
-- **TX03_S02**: Context 압축 알고리즘 구현 (completed → 2025-07-09 03:48 완료)
-- **TX11_S01**: 통합 테스트 Suite 구축 (completed → 2025-07-09 03:06 완료)
-- **TX10_S01**: update_docs 명령어 복구 (completed → 2025-07-09 02:49 완료)
-- **TX09_S01**: 압축 알고리즘 프로토타입 (completed → 2025-07-09 02:35 완료)
-- **TX08_S01**: 토큰 추적 시스템 프로토타입 (completed → 2025-07-09 02:12 완료)
-- **TX07_S01**: Context 압축 아키텍처 설계 (completed → 2025-07-09 01:54 완료)
-- **TX05_S01**: AI 페르소나 데이터 구조 설계 (completed → 2025-07-09 01:25 완료)
-- **TX04_S01**: Feature Ledger 문서화 (completed → 2025-07-09 01:02 완료)
-- **TX03_S01**: Git 연동 Feature 추적 (completed → 2025-07-09 00:45 완료)
-- **TX02_S01**: Feature Ledger CLI 명령어 개발 (completed → 2025-07-09 00:18 완료)
-- **TX01_S01**: Feature Ledger 데이터 구조 설계 (completed → 2025-07-09 00:01 완료)
-- **T04_S03**: update_docs 명령어 누락 이슈 해결 (completed → 2025-07-03 06:35 완료)
-- **T03_S03**: 한국어 명령어 전체 시스템 표준화 (completed → 2025-07-03 06:28 완료)
-
-### 완료됨
-
-- 프로젝트 초기화 완료
-- M01 마일스톤 완료 (한국어 명령어 표준화)
-
-## 마일스톤 목록
-
-| ID  | 이름                            | 상태    | 진행률 | 시작일     | 완료일 |
-| --- | ------------------------------- | ------- | ------ | ---------- | ------ |
-| M02 | Context_Engineering_Enhancement | 완료 | 100%   | 2025-07-08 | 2025-07-08 |
-| M03 | AIWF_Simplification_Reliability | 계획 중 | 0%    | TBD        | TBD    |
-
-### 마일스톤 상세
-- [x] [M02: Context Engineering Enhancement](02_REQUIREMENTS/M02_Context_Engineering_Enhancement/M02_milestone_meta.md) - 상태: 완료
-- [ ] [M03: AIWF 단순화 및 신뢰성 강화](02_REQUIREMENTS/M03_Simone_Integration_Enhancement/M03_milestone_meta.md) - 상태: 계획 중
-
-## 스프린트 목록
-
-| ID  | 이름                          | 마일스톤 | 상태      | 진행률 | 시작일     | 완료일 |
-| --- | ----------------------------- | -------- | --------- | ------ | ---------- | ------ |
-| S01 | context_foundation            | M02      | complete  | 100%   | 2025-07-08 | 2025-07-08 |
-| S02 | ai_enhancement                | M02      | complete  | 100%   | 2025-07-08 | 2025-07-08 |
-| S03 | ecosystem_integration         | M02      | complete  | 100%   | 2025-07-08 | 2025-07-08 |
-
-## 일반 태스크
-
-- [x] [TX001: Complete English Translation for 100% i18n Support](04_GENERAL_TASKS/TX001_complete_english_translation.md) - 상태: 완료
-
-## 태스크 통계
-
-- **총 태스크**: 19
-- **완료**: 19
-- **진행 중**: 0
-- **대기 중**: 0
-- **차단됨**: 0
-
-## 프로젝트 메트릭
-
-- **코드 커버리지**: N/A (NPM 패키지)
-- **활성 이슈**: 0
-- **해결된 이슈**: 0
-- **오픈 PR**: 0
-
-## 기술 스택
-
-- **언어**: JavaScript (ES6+)
-- **런타임**: Node.js 14.0.0+
-- **패키지 매니저**: NPM
-- **테스트**: Jest
-- **CLI 도구**: Commander.js, Chalk, Ora, Prompts
-
-## 주요 디렉토리
-
-- `index.js`: 메인 CLI 설치 도구
-- `claude-code/aiwf/ko/`: 한국어 AIWF 프레임워크
-- `claude-code/aiwf/en/`: 영어 AIWF 프레임워크
-- `rules/`: IDE별 개발 규칙
-- `docs/`: 프로젝트 문서
-- `tests/`: 테스트 파일
-
-## 연락처 및 리소스
-
-- **저자**: moonklabs
-- **라이선스**: MIT
-- **저장소**: https://github.com/aiwf/aiwf
-- **NPM**: https://www.npmjs.com/package/aiwf
-- **이슈 트래커**: https://github.com/aiwf/aiwf/issues
-
-## 주요 변경사항 로그
-
-### 2025-07-10
-
-- 스프린트 태스크 상태 업데이트:
-  - S01_M02: 실제로 11/12 태스크 구현 완료 (테스크 파일에는 4/12로 표시됨)
-    - AI 페르소나, Context 압축, 토큰 추적 시스템 모두 구현됨
-    - Feature Ledger CLI 명령어만 미구현
-  - S02_M02: 태스크 파일과 구현의 불일치 확인
-    - 6개 페르소나 구현 (계획 5개와 다른 이름)
-    - Feature-Git 연동 부분 구현
-  - S03_M02: AI 도구 템플릿 및 프로젝트 템플릿 미구현
-    - Claude Code 템플릿만 존재
-    - 오프라인 캐시 시스템은 구현됨
-
-### 2025-07-08
-
-- S02 스프린트 완료: AI 강화 기능 구현
-  - 5개 AI 페르소나 명령어 구현 완료
-  - Context 압축 알고리즘 구현 (토큰 50% 절약 달성)
-  - Feature-Git 연동 시스템 구축
-  - 모든 DoD 항목 충족
-- M01 마일스톤 삭제 (완료됨)
-- M02 Context Engineering Enhancement 마일스톤을 위한 스프린트 재구성:
-  - S01_M02_context_foundation: Feature Ledger, AI 페르소나, Context 압축 기반 구축
-  - S02_M02_ai_enhancement: 5개 AI 페르소나, Context 압축 모드, Git 연동 구현
-  - S03_M02_ecosystem_integration: 5개 AI 도구 템플릿, 통합 및 문서화 완성
-- M02 DoD 요구사항에 맞춘 스프린트 재정의
-- 1주일 단위 실행 가능한 범위로 조정
-
-### 2025-07-02
-
-- AIWF 프로젝트 초기화 완료
-- 아키텍처 문서 생성
-- M01 한국어 명령어 표준화 마일스톤 시작
-- T03_S03 태스크 생성
-
-## 향후 계획
-
-### M03: AIWF 단순화 및 신뢰성 강화 (계획 중)
-
-**목표**: 태스크 상태 불일치 해결 및 CLI 인터페이스 단순화
-
-1. **Week 1: 프로젝트 정리 및 기초 구축**:
-   - 프로젝트 구조 정리 (중복 파일 제거, 모듈화)
-   - JSON 기반 태스크 인덱스 시스템 설계
-   - CLI 실행 파일 기본 구현
-
-2. **Week 2: 핵심 기능 구현**:
-   - 태스크 무결성 검사 시스템
-   - 안전한 상태 변경 명령어
-   - 기본 AI 도우미 (research, plan)
-
-3. **Week 3: 통합 및 완성**:
-   - 향상된 사용자 경험 (컬러 출력, 에러 메시지)
-   - 테스트 및 문서화
-   - v0.4.0 릴리즈 준비
-
-**제거된 오버엔지니어링**: SQLite DB, MCP 서버 통합, 웹 대시보드, 병렬 처리
-
-### 레거시 목표
-
-1. **즉시 조치 필요 사항**:
-   - Feature Ledger CLI 명령어 구현 (aiwf_create_feature_ledger, aiwf_update_feature_status 등)
-   - AI 도구 템플릿 4개 추가 (GitHub Copilot, Cursor, Windsurf, Augment)
-   - 프로젝트 템플릿 시스템 구현
-   - `.aiwf/ai-tools/` 및 `.aiwf/07_AI_PERSONAS/` 디렉토리 생성
-
-2. **장기 목표**:
-   - 새로운 언어 지원 추가
-   - 커뮤니티 생태계 구축

package/.aiwf/01_PROJECT_DOCS/ARCHITECTURE.md

@@ -1,121 +0,0 @@
-# AIWF (AI Workflow Framework) 아키텍처
-
-## 프로젝트 개요
-
-AIWF는 Claude Code와의 통합을 위해 설계된 마크다운 기반 프로젝트 관리 프레임워크입니다. AI 지원 개발을 위한 체계적인 워크플로우를 제공하며, 다국어 지원(한국어/영어)을 통해 글로벌 개발자들이 사용할 수 있도록 설계되었습니다.
-
-## 핵심 목적
-
-- AI가 효과적으로 처리할 수 있는 관리 가능한 단위로 소프트웨어 프로젝트를 분해
-- Claude Code와의 완벽한 통합을 통한 개발 생산성 극대화
-- 체계적인 프로젝트 관리 및 추적 시스템 제공
-- 다국어 환경에서의 일관된 개발 경험 보장
-
-## 핵심 아키텍처 구성요소
-
-### 1. CLI 설치 도구 (index.js)
-- **역할**: GitHub에서 AIWF 프레임워크 구성요소를 다운로드하고 설치하는 메인 진입점
-- **기술 스택**: Node.js ES modules, Commander.js, Chalk, Ora, Prompts
-- **핵심 기능**:
-  - GitHub API 통합으로 최신 프레임워크 컨텐츠 가져오기
-  - 대화형 언어 선택 (한국어/영어)
-  - 자동 백업 및 업데이트 시스템
-  - IDE별 규칙 변환 (Cursor, Windsurf)
-
-### 2. AIWF 프레임워크 (claude-code/aiwf/)
-- **구조**: 언어별 분리된 디렉토리 구조 (`ko/`, `en/`)
-- **구성요소**:
-  - `.claude/commands/`: Claude Code 커스텀 명령어
-  - `.aiwf/`: 프로젝트 관리 구조 및 템플릿
-
-### 3. 규칙 시스템 (rules/)
-- **Global Rules**: 항상 적용되는 개발 가이드라인
-- **Manual Rules**: 필요에 따라 적용하는 규칙들
-- **IDE 통합**: Cursor와 Windsurf IDE를 위한 특화된 규칙 변환
-
-## 기술적 아키텍처 결정사항
-
-### 다국어 지원 전략
-- **언어별 분리**: `ko/`, `en/` 폴더를 통한 완전한 언어별 컨텐츠 분리
-- **설치 시점 선택**: 사용자가 설치 시 언어를 선택하여 해당 언어 버전만 설치
-- **명령어 현지화**: 언어별 Claude Code 명령어 제공
-
-### GitHub 통합 전략
-- **직접 다운로드**: GitHub API를 통한 실시간 컨텐츠 페치
-- **무인증 액세스**: GitHub API 속도 제한 내에서 동작
-- **마스터 브랜치 기준**: 항상 최신 안정 버전 제공
-
-### 파일 관리 전략
-- **원자적 연산**: 백업/복원 기능을 통한 안전한 업데이트
-- **선택적 업데이트**: 
-  - CLAUDE.md 파일: 항상 업데이트
-  - 명령어: 항상 업데이트
-  - 템플릿: 신규 설치 시만 다운로드
-  - 사용자 컨텐츠: 업데이트 중 보존
-
-## 프로젝트 관리 워크플로우
-
-### 명령어 구조
-```
-/project:aiwf:<command>
-```
-
-### 핵심 명령어 카테고리
-1. **설정**: `initialize`, `prime`
-2. **계획**: `plan_milestone`, `create_sprints_from_milestone`
-3. **개발**: `do_task`, `commit`, `test`, `code_review`
-4. **자동화**: `yolo` (자율 실행)
-5. **GitHub 통합**: `issue_create`, `pr_create`
-6. **분석**: `ultrathink_*`, `mermaid`, `project_review`
-
-### 디렉토리 구조 규칙
-```
-.aiwf/
-├── 00_PROJECT_MANIFEST.md     # 중앙 추적 문서
-├── 01_PROJECT_DOCS/           # 프로젝트 문서
-├── 02_REQUIREMENTS/           # 마일스톤 요구사항
-├── 03_SPRINTS/               # 스프린트 실행 추적
-├── 04_GENERAL_TASKS/         # 독립적 태스크
-├── 05_ARCHITECTURE_DECISIONS/ # ADR 문서
-├── 10_STATE_OF_PROJECT/      # 프로젝트 상태 스냅샷
-├── 98_PROMPTS/               # 유용한 AI 프롬프트
-└── 99_TEMPLATES/             # 문서 템플릿
-```
-
-## 중요한 기술적 제약사항
-
-### 설치 안전성
-- 사용자가 생성한 프로젝트 컨텐츠는 절대 덮어쓰지 않음
-- 업데이트 전 항상 백업 생성
-- 스프린트 및 태스크의 기존 작업 보존
-
-### Node.js 요구사항
-- 최소 Node.js 14.0.0
-- ES 모듈 사용 (`"type": "module"`)
-- `https` 및 `fs/promises` 지원 필요
-
-### 네트워크 의존성
-- 설치를 위한 인터넷 연결 필요
-- 라이브 GitHub 저장소에서 모든 컨텐츠 가져오기
-- GitHub API 속도 제한 고려 (미인증)
-
-## 보안 고려사항
-
-- GitHub API를 통한 안전한 컨텐츠 다운로드
-- 사용자 로컬 파일 시스템에 대한 안전한 파일 조작
-- 백업 메커니즘을 통한 데이터 손실 방지
-
-## 확장성 고려사항
-
-### 새로운 언어 추가
-1. `claude-code/aiwf/{lang_code}/` 디렉토리 생성
-2. 기존 언어에서 컨텐츠 복사 및 번역
-3. `index.js`의 `messages` 객체에 언어 옵션 추가
-4. 언어 선택 프롬프트 업데이트
-
-### 새로운 명령어 추가
-1. 언어별 디렉토리에 명령어 파일 생성
-2. 명명 규칙 준수 (한국어 버전은 `_kr` 접미사 가능)
-3. 문서 업데이트
-
-이 아키텍처는 안정성과 사용자 안전을 중시하며, 광범위한 오류 처리와 백업 메커니즘을 통해 여러 언어에서 안정적인 프레임워크 배포를 보장합니다.