aiwf 0.3.21 → 0.3.23

package/src/lib/resources/personas/architect/best_practices.md

@@ -1,136 +0,0 @@
-# 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/src/lib/resources/personas/architect/knowledge_base.md

@@ -1,377 +0,0 @@
-# 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/src/lib/resources/personas/architect.json

@@ -1,44 +0,0 @@
-{
-  "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"
-  ]
-}