aiwf 0.3.8 → 0.3.12

package/claude-code/aiwf/ko/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/claude-code/aiwf/ko/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"
-  ]
-}