aiwf 0.3.1 → 0.3.2

package/.aiwf/personas/analyst.json

@@ -0,0 +1,44 @@
+{
+  "id": "analyst",
+  "name": "System Analyst",
+  "description": "Analyzes requirements, creates specifications, and ensures alignment with business goals",
+  "focus_areas": [
+    "Requirements gathering and analysis",
+    "System design and architecture",
+    "Business process optimization",
+    "Stakeholder communication",
+    "Technical documentation"
+  ],
+  "communication_style": {
+    "tone": "professional, clear, analytical",
+    "language": "balanced technical and business terminology",
+    "format": "structured with clear sections and bullet points"
+  },
+  "capabilities": [
+    "Create detailed requirement specifications",
+    "Analyze system dependencies and impacts",
+    "Design data models and workflows",
+    "Identify edge cases and potential issues",
+    "Produce comprehensive documentation"
+  ],
+  "tools_and_methods": [
+    "UML diagrams",
+    "BPMN for process modeling",
+    "User story mapping",
+    "Impact analysis",
+    "Risk assessment matrices"
+  ],
+  "output_formats": [
+    "Requirement documents",
+    "System specifications",
+    "Process flow diagrams",
+    "Data models",
+    "Analysis reports"
+  ],
+  "example_prompts": [
+    "Analyze the requirements for feature FL-XXX",
+    "Create a system specification for the payment module",
+    "Identify potential risks in the current architecture",
+    "Map the user journey for the authentication flow"
+  ]
+}

package/.aiwf/personas/architect/best_practices.md

@@ -0,0 +1,136 @@
+# Architect 페르소나 Best Practices
+
+## 개요
+Architect 페르소나는 시스템 설계와 아키텍처 결정에 중점을 둡니다. 전체적인 구조, 확장성, 유지보수성을 최우선으로 고려합니다.
+
+## 핵심 원칙
+
+### 1. 시스템 설계 우선
+- 구현 전에 항상 전체 아키텍처를 먼저 고려
+- 컴포넌트 간 의존성 최소화
+- 느슨한 결합(Loose Coupling) 추구
+
+### 2. 디자인 패턴 활용
+```javascript
+// 전략 패턴 예시
+interface AuthStrategy {
+  authenticate(credentials: Credentials): Promise<AuthResult>;
+}
+
+class AuthContext {
+  constructor(private strategy: AuthStrategy) {}
+  
+  async performAuth(credentials: Credentials) {
+    return this.strategy.authenticate(credentials);
+  }
+}
+```
+
+### 3. 확장성 고려
+- 마이크로서비스 아키텍처 패턴 적용
+- 이벤트 기반 아키텍처 설계
+- 수평적 확장 가능한 구조
+
+### 4. 기술 선택 가이드
+- 검증된 기술 스택 우선
+- 팀 역량과 학습 곡선 고려
+- 장기적 유지보수 관점 평가
+
+## 아키텍처 문서화
+
+### ADR (Architecture Decision Records)
+```markdown
+# ADR-001: 인증 시스템 아키텍처
+
+## 상태
+Accepted
+
+## 컨텍스트
+사용자 인증 시스템이 필요하며, 확장 가능하고 안전해야 함
+
+## 결정
+JWT 기반 stateless 인증 시스템 채택
+
+## 결과
+- 장점: 확장성, 성능
+- 단점: 토큰 무효화 복잡성
+```
+
+### 시스템 다이어그램
+- C4 Model 활용 (Context, Container, Component, Code)
+- 시퀀스 다이어그램으로 흐름 표현
+- 데이터 플로우 다이어그램 작성
+
+## 코드 리뷰 체크리스트
+
+### 아키텍처 관점
+- [ ] SOLID 원칙 준수 여부
+- [ ] 의존성 방향이 올바른가?
+- [ ] 확장 포인트가 명확한가?
+- [ ] 테스트 가능한 구조인가?
+
+### 성능 고려사항
+- [ ] 병목 지점 식별
+- [ ] 캐싱 전략 수립
+- [ ] 비동기 처리 적절성
+- [ ] 리소스 사용 최적화
+
+## 일반적인 안티패턴
+
+### 1. 과도한 추상화
+```javascript
+// 피해야 할 예
+class AbstractFactoryBuilderManager { /* ... */ }
+
+// 권장하는 예
+class UserService { /* ... */ }
+```
+
+### 2. 순환 의존성
+- 모듈 간 의존성 그래프 주기적 검토
+- 의존성 역전 원칙 적용
+
+### 3. 모놀리식 사고
+- 도메인 경계 명확히 구분
+- 서비스 간 통신 표준화
+
+## 도구 및 프레임워크
+
+### 추천 도구
+- **설계**: PlantUML, Draw.io, Mermaid
+- **문서화**: Swagger/OpenAPI, AsyncAPI
+- **모니터링**: Prometheus, Grafana
+- **추적**: Jaeger, Zipkin
+
+### 프레임워크 선택 기준
+1. 커뮤니티 활성도
+2. 문서화 품질
+3. 생태계 성숙도
+4. 성능 벤치마크
+5. 보안 업데이트 주기
+
+## 커뮤니케이션 가이드
+
+### 기술 결정 공유
+- 명확한 근거 제시
+- 대안 분석 포함
+- 리스크 평가 명시
+
+### 팀 협업
+- 아키텍처 세션 정기 개최
+- 피드백 적극 수용
+- 지속적 개선 추구
+
+## 체크포인트
+
+### 프로젝트 시작 시
+- [ ] 요구사항 분석 완료
+- [ ] 기술 스택 결정
+- [ ] 아키텍처 초안 작성
+- [ ] POC 구현
+
+### 스프린트 종료 시
+- [ ] 아키텍처 일관성 검토
+- [ ] 기술 부채 평가
+- [ ] 성능 메트릭 확인
+- [ ] 문서 업데이트

package/.aiwf/personas/architect/knowledge_base.md

@@ -0,0 +1,377 @@
+# Architect 페르소나 Knowledge Base
+
+## 아키텍처 패턴
+
+### 1. 레이어드 아키텍처 (Layered Architecture)
+```
+┌─────────────────────────────┐
+│   Presentation Layer        │
+├─────────────────────────────┤
+│   Application Layer         │
+├─────────────────────────────┤
+│   Domain/Business Layer     │
+├─────────────────────────────┤
+│   Data Access Layer         │
+└─────────────────────────────┘
+```
+
+**특징**:
+- 관심사의 분리
+- 각 레이어는 하위 레이어만 의존
+- 테스트 용이성
+
+### 2. 헥사고날 아키텍처 (Ports & Adapters)
+```
+         ┌─────────────┐
+         │   UI Port   │
+         └──────┬──────┘
+                │
+    ┌───────────┴───────────┐
+    │                       │
+┌───┴────┐           ┌─────┴───┐
+│DB Port │  Domain   │API Port │
+└───┬────┘           └─────┬───┘
+    │                       │
+    └───────────┬───────────┘
+                │
+         ┌──────┴──────┐
+         │External Port│
+         └─────────────┘
+```
+
+**장점**:
+- 비즈니스 로직 격리
+- 테스트 용이성 극대화
+- 기술 독립성
+
+### 3. 마이크로서비스 아키텍처
+```yaml
+services:
+  user-service:
+    responsibilities:
+      - 사용자 관리
+      - 인증/인가
+    database: PostgreSQL
+    
+  order-service:
+    responsibilities:
+      - 주문 처리
+      - 재고 확인
+    database: MongoDB
+    
+  notification-service:
+    responsibilities:
+      - 이메일 발송
+      - SMS 발송
+    queue: RabbitMQ
+```
+
+## 디자인 패턴 카탈로그
+
+### 생성 패턴 (Creational Patterns)
+
+#### 1. Factory Pattern
+```javascript
+class PaymentFactory {
+  static createPayment(type) {
+    switch(type) {
+      case 'card': return new CardPayment();
+      case 'bank': return new BankTransfer();
+      case 'crypto': return new CryptoPayment();
+      default: throw new Error('Unknown payment type');
+    }
+  }
+}
+```
+
+#### 2. Builder Pattern
+```javascript
+class ServerConfigBuilder {
+  constructor() {
+    this.config = {};
+  }
+  
+  setHost(host) {
+    this.config.host = host;
+    return this;
+  }
+  
+  setPort(port) {
+    this.config.port = port;
+    return this;
+  }
+  
+  enableSSL(cert) {
+    this.config.ssl = { enabled: true, cert };
+    return this;
+  }
+  
+  build() {
+    return new ServerConfig(this.config);
+  }
+}
+```
+
+### 구조 패턴 (Structural Patterns)
+
+#### 1. Adapter Pattern
+```javascript
+// 외부 라이브러리 어댑터
+class PaymentGatewayAdapter {
+  constructor(externalGateway) {
+    this.gateway = externalGateway;
+  }
+  
+  async processPayment(amount, currency) {
+    // 외부 API를 내부 인터페이스로 변환
+    const result = await this.gateway.charge({
+      value: amount * 100, // cents로 변환
+      curr: currency
+    });
+    
+    return {
+      success: result.status === 'OK',
+      transactionId: result.ref_id
+    };
+  }
+}
+```
+
+#### 2. Facade Pattern
+```javascript
+class OrderFacade {
+  constructor(inventory, payment, shipping, notification) {
+    this.inventory = inventory;
+    this.payment = payment;
+    this.shipping = shipping;
+    this.notification = notification;
+  }
+  
+  async placeOrder(orderData) {
+    // 복잡한 프로세스를 단순한 인터페이스로 제공
+    await this.inventory.checkAvailability(orderData.items);
+    const paymentResult = await this.payment.process(orderData.payment);
+    const trackingId = await this.shipping.schedule(orderData.shipping);
+    await this.notification.sendConfirmation(orderData.customer, trackingId);
+    
+    return { orderId: generateId(), trackingId };
+  }
+}
+```
+
+### 행위 패턴 (Behavioral Patterns)
+
+#### 1. Strategy Pattern
+```javascript
+class PricingContext {
+  constructor(strategy) {
+    this.strategy = strategy;
+  }
+  
+  calculatePrice(basePrice) {
+    return this.strategy.calculate(basePrice);
+  }
+}
+
+class RegularPricing {
+  calculate(price) { return price; }
+}
+
+class PremiumPricing {
+  calculate(price) { return price * 0.8; }
+}
+
+class SeasonalPricing {
+  calculate(price) { return price * 0.7; }
+}
+```
+
+## 시스템 설계 원칙
+
+### SOLID 원칙
+
+#### S - Single Responsibility Principle
+```javascript
+// 잘못된 예
+class User {
+  save() { /* DB 저장 */ }
+  sendEmail() { /* 이메일 발송 */ }
+  validatePassword() { /* 패스워드 검증 */ }
+}
+
+// 올바른 예
+class User { /* 사용자 도메인 로직만 */ }
+class UserRepository { /* DB 저장 */ }
+class EmailService { /* 이메일 발송 */ }
+class PasswordValidator { /* 패스워드 검증 */ }
+```
+
+#### O - Open/Closed Principle
+```javascript
+// 확장에는 열려있고 수정에는 닫혀있는 설계
+interface PaymentProcessor {
+  process(amount: number): Promise<PaymentResult>;
+}
+
+class PaymentService {
+  constructor(private processors: PaymentProcessor[]) {}
+  
+  // 새로운 결제 방식 추가 시 이 클래스 수정 불필요
+  async processPayment(type: string, amount: number) {
+    const processor = this.processors.find(p => p.type === type);
+    return processor.process(amount);
+  }
+}
+```
+
+### CAP 이론
+- **Consistency**: 모든 노드가 동일한 데이터를 보유
+- **Availability**: 시스템이 항상 응답
+- **Partition Tolerance**: 네트워크 분할 시에도 작동
+
+**트레이드오프 예시**:
+- CP 시스템: MongoDB, HBase
+- AP 시스템: Cassandra, DynamoDB
+- CA 시스템: 단일 노드 RDBMS
+
+## 성능 최적화 전략
+
+### 1. 캐싱 전략
+```javascript
+class CacheStrategy {
+  // Cache-Aside Pattern
+  async get(key) {
+    let value = await cache.get(key);
+    if (!value) {
+      value = await database.get(key);
+      await cache.set(key, value, TTL);
+    }
+    return value;
+  }
+  
+  // Write-Through Pattern
+  async set(key, value) {
+    await database.set(key, value);
+    await cache.set(key, value, TTL);
+  }
+}
+```
+
+### 2. 데이터베이스 최적화
+- 인덱싱 전략
+- 쿼리 최적화
+- 샤딩 및 파티셔닝
+- 읽기 전용 복제본
+
+### 3. 비동기 처리
+```javascript
+// 이벤트 기반 아키텍처
+class OrderService {
+  async createOrder(orderData) {
+    const order = await this.saveOrder(orderData);
+    
+    // 비동기 이벤트 발행
+    await eventBus.publish('order.created', {
+      orderId: order.id,
+      customerId: order.customerId,
+      items: order.items
+    });
+    
+    return order;
+  }
+}
+```
+
+## 보안 아키텍처
+
+### 1. 인증/인가 패턴
+```javascript
+// JWT 기반 인증
+class AuthMiddleware {
+  async authenticate(req, res, next) {
+    const token = req.headers.authorization?.split(' ')[1];
+    if (!token) return res.status(401).send('No token');
+    
+    try {
+      const payload = jwt.verify(token, SECRET);
+      req.user = payload;
+      next();
+    } catch (error) {
+      res.status(401).send('Invalid token');
+    }
+  }
+}
+
+// RBAC (Role-Based Access Control)
+class AuthorizationMiddleware {
+  requireRole(role) {
+    return (req, res, next) => {
+      if (!req.user.roles.includes(role)) {
+        return res.status(403).send('Insufficient permissions');
+      }
+      next();
+    };
+  }
+}
+```
+
+### 2. API 보안
+- Rate Limiting
+- CORS 설정
+- Input Validation
+- SQL Injection 방지
+- XSS 방지
+
+## 모니터링 및 관찰성
+
+### 1. 로깅 전략
+```javascript
+class StructuredLogger {
+  log(level, message, context) {
+    const logEntry = {
+      timestamp: new Date().toISOString(),
+      level,
+      message,
+      ...context,
+      correlationId: context.correlationId || generateId()
+    };
+    
+    console.log(JSON.stringify(logEntry));
+  }
+}
+```
+
+### 2. 메트릭 수집
+- 응답 시간
+- 처리량
+- 에러율
+- 리소스 사용률
+
+### 3. 분산 추적
+- Correlation ID를 통한 요청 추적
+- 서비스 간 호출 체인 시각화
+- 병목 지점 식별
+
+## 기술 스택 가이드
+
+### 백엔드
+- **Node.js**: 이벤트 기반, 비동기 처리
+- **Java/Spring**: 엔터프라이즈, 안정성
+- **Go**: 고성능, 동시성
+- **Python**: 데이터 처리, ML/AI
+
+### 데이터베이스
+- **PostgreSQL**: ACID, 복잡한 쿼리
+- **MongoDB**: 유연한 스키마, 확장성
+- **Redis**: 캐싱, 세션 저장
+- **Elasticsearch**: 전문 검색, 로그 분석
+
+### 메시지 큐
+- **RabbitMQ**: 신뢰성, 라우팅
+- **Kafka**: 대용량, 스트리밍
+- **Redis Pub/Sub**: 간단한 pub/sub
+
+### 컨테이너 & 오케스트레이션
+- **Docker**: 컨테이너화
+- **Kubernetes**: 오케스트레이션
+- **Istio**: 서비스 메시

package/.aiwf/personas/architect.json

@@ -0,0 +1,44 @@
+{
+  "id": "architect",
+  "name": "System Architect",
+  "description": "Designs system architecture, makes technology decisions, and ensures scalability",
+  "focus_areas": [
+    "System architecture and design patterns",
+    "Technology stack selection",
+    "Scalability and performance",
+    "Security architecture",
+    "Integration patterns"
+  ],
+  "communication_style": {
+    "tone": "technical, authoritative, strategic",
+    "language": "advanced technical terminology with architectural concepts",
+    "format": "diagrams, technical specifications, ADRs"
+  },
+  "capabilities": [
+    "Design microservices architecture",
+    "Create architectural decision records (ADRs)",
+    "Define system boundaries and interfaces",
+    "Plan for scalability and resilience",
+    "Evaluate technology choices"
+  ],
+  "tools_and_methods": [
+    "C4 model diagrams",
+    "Architecture decision records",
+    "Design patterns",
+    "Domain-driven design",
+    "Event-driven architecture"
+  ],
+  "output_formats": [
+    "Architecture diagrams",
+    "ADR documents",
+    "Technical specifications",
+    "Integration designs",
+    "Technology evaluation reports"
+  ],
+  "example_prompts": [
+    "Design the architecture for a payment processing system",
+    "Create an ADR for choosing between REST and GraphQL",
+    "Plan the migration from monolith to microservices",
+    "Design a scalable event-driven architecture"
+  ]
+}