@kood/claude-code 0.6.5 → 0.6.7

package/templates/.claude/skills/project-optimizer/rules/dx-lint-config.md

@@ -0,0 +1,36 @@
+---
+title: Optimize Linter and Formatter Configuration
+impact: MEDIUM
+impactDescription: Consistent code style, faster feedback loop
+tags: dx, lint, format, eslint, prettier, biome, ruff
+languages: all
+related: [dx-type-safety, code-complexity]
+---
+
+## 린터/포매터 최적 설정
+
+프로젝트에 맞는 린터/포매터를 설정하여 일관된 코드 스타일과 빠른 피드백을 보장합니다.
+
+**언어별 권장 도구 (2026):**
+
+| 언어 | 린터 | 포매터 | 비고 |
+|------|------|--------|------|
+| **JS/TS** | ESLint 9 (flat config) | Prettier 또는 Biome | Biome = lint+format 올인원 |
+| **Python** | Ruff | Ruff (format) | flake8+isort+black 100x 빠른 대체 |
+| **Go** | go vet + staticcheck | gofmt (내장) | |
+| **Rust** | clippy | rustfmt (내장) | |
+| **Java** | SpotBugs / Error Prone | google-java-format | |
+
+**빠른 피드백을 위한 설정:**
+
+```json
+// lint-staged (Git 커밋 시 변경 파일만)
+{
+  "*.{ts,tsx}": ["eslint --fix", "prettier --write"],
+  "*.py": ["ruff check --fix", "ruff format"],
+  "*.go": ["gofmt -w"],
+  "*.rs": ["rustfmt"]
+}
+```
+
+**원칙:** 전체 프로젝트 린트는 CI에서, 로컬은 변경 파일만 (lint-staged).

package/templates/.claude/skills/project-optimizer/rules/dx-test-coverage.md

@@ -0,0 +1,34 @@
+---
+title: Ensure Test Coverage on Critical Paths
+impact: MEDIUM
+impactDescription: Confidence in refactoring, catches regressions
+tags: dx, test, coverage, critical-path
+languages: all
+related: [code-error-handling, dx-ci-speed]
+---
+
+## 핵심 로직 테스트 커버리지 확보
+
+100% 커버리지보다 핵심 비즈니스 로직의 높은 커버리지가 중요합니다.
+
+**우선순위:**
+
+| 우선순위 | 대상 | 이유 |
+|---------|------|------|
+| **1** | 비즈니스 로직/도메인 | 변경 빈도 높음, 버그 영향 큼 |
+| **2** | 데이터 변환/파싱 | 엣지 케이스 많음 |
+| **3** | API 엔드포인트 | 외부 계약 |
+| **4** | 에러 처리 경로 | 간과하기 쉬움 |
+| LOW | UI 컴포넌트 렌더링 | 자주 변경, ROI 낮음 |
+| LOW | 외부 서비스 호출 | Mock 필요, 깨지기 쉬움 |
+
+**테스트 도구 (2026):**
+
+| 언어 | 도구 | 특징 |
+|------|------|------|
+| **JS/TS** | Vitest | Vite 통합, ESM 네이티브, 빠름 |
+| **Python** | pytest | 풍부한 에코시스템 |
+| **Go** | testing (내장) | `go test -cover` |
+| **Rust** | cargo test (내장) | `cargo tarpaulin` (커버리지) |
+
+**목표:** 핵심 로직 80%+, 전체 60%+ (프로젝트 성격에 따라 조정).

package/templates/.claude/skills/project-optimizer/rules/dx-type-safety.md

@@ -0,0 +1,49 @@
+---
+title: Maximize Type System Usage
+impact: MEDIUM
+impactDescription: Catches bugs at compile time, better IDE support
+tags: dx, type, safety, strict, generics
+languages: [ts, go, rust, java, csharp]
+related: [code-error-handling, code-naming]
+---
+
+## 타입 시스템 최대 활용
+
+언어의 타입 시스템을 최대한 활용하여 런타임 에러를 컴파일 타임에 잡습니다.
+
+**언어별 strict 설정:**
+
+```json
+// TypeScript - tsconfig.json
+{ "compilerOptions": { "strict": true, "noUncheckedIndexedAccess": true } }
+```
+
+```toml
+# Rust - Clippy strict
+[lints.clippy]
+pedantic = "warn"
+```
+
+```python
+# Python - mypy strict
+[tool.mypy]
+strict = true
+disallow_any_generics = true
+```
+
+```go
+// Go - go vet + staticcheck
+// go vet ./...
+// staticcheck ./...
+```
+
+**패턴:**
+
+| 패턴 | 효과 | 언어 |
+|------|------|------|
+| **Discriminated union** | 상태별 안전한 분기 | TS, Rust (enum), Python (Literal) |
+| **Branded type** | 같은 원시형 혼동 방지 | TS (`type UserId = string & { __brand: 'UserId' }`) |
+| **Exhaustive check** | switch에서 누락 분기 감지 | TS (`never`), Rust (match), Go (exhaustive) |
+| **Generic constraint** | 타입 파라미터 제한 | 모든 정적 타입 언어 |
+
+**원칙:** `any`/`object`/`interface{}` 사용 최소화. 가능한 가장 구체적인 타입 사용.

package/templates/.claude/skills/project-optimizer/rules/io-batch-queries.md

@@ -0,0 +1,67 @@
+---
+title: Batch Queries to Eliminate N+1
+impact: HIGH
+impactDescription: 100x fewer queries, 10x faster response
+tags: io, database, n+1, batch, query
+languages: all
+related: [concurrency-parallel, io-cache-layer]
+---
+
+## N+1 쿼리 제거
+
+목록 조회 후 각 항목마다 추가 쿼리를 실행하는 N+1 패턴을 배치/조인으로 전환합니다.
+
+**❌ 잘못된 예시 (N+1):**
+
+```python
+# 100명 유저 = 101 쿼리
+users = db.query("SELECT * FROM users")
+for user in users:
+    orders = db.query(f"SELECT * FROM orders WHERE user_id = {user.id}")
+```
+
+```typescript
+// Prisma N+1
+const users = await prisma.user.findMany()
+for (const user of users) {
+  const orders = await prisma.order.findMany({ where: { userId: user.id } })
+}
+```
+
+**✅ 올바른 예시 (배치/조인):**
+
+```python
+# 2 쿼리
+users = db.query("SELECT * FROM users")
+user_ids = [u.id for u in users]
+orders = db.query("SELECT * FROM orders WHERE user_id = ANY($1)", user_ids)
+
+# SQLAlchemy - eager loading
+users = session.query(User).options(selectinload(User.orders)).all()
+```
+
+```typescript
+// Prisma - include
+const users = await prisma.user.findMany({
+  include: { orders: true }
+})
+```
+
+```go
+// GORM - Preload
+var users []User
+db.Preload("Orders").Find(&users)
+```
+
+```ruby
+# ActiveRecord - includes
+users = User.includes(:orders).all
+```
+
+```java
+// JPA - EntityGraph
+@EntityGraph(attributePaths = {"orders"})
+List<User> findAll();
+```
+
+**감지 방법:** 쿼리 로그에서 반복되는 유사 쿼리 패턴 확인. ORM 쿼리 카운터 활용.

package/templates/.claude/skills/project-optimizer/rules/io-cache-layer.md

@@ -0,0 +1,67 @@
+---
+title: Add Cache Layer for Repeated Reads
+impact: HIGH
+impactDescription: 10-100x latency reduction for cached data
+tags: io, cache, lru, ttl, redis, in-memory
+languages: all
+related: [io-batch-queries, memory-bounded-cache]
+---
+
+## 반복 읽기에 캐시 레이어 추가
+
+동일 데이터를 반복 조회하는 경우 인메모리/외부 캐시를 추가하여 DB/API 부하를 줄입니다.
+
+**❌ 잘못된 예시 (매번 DB 조회):**
+
+```python
+def get_user(user_id: str) -> User:
+    return db.query("SELECT * FROM users WHERE id = $1", user_id)
+```
+
+**✅ 올바른 예시 (캐시 레이어):**
+
+```python
+# Python (functools.lru_cache)
+from functools import lru_cache
+
+@lru_cache(maxsize=1000)
+def get_config(key: str) -> str:
+    return db.query("SELECT value FROM config WHERE key = $1", key)
+
+# TTL 있는 캐시 (cachetools)
+from cachetools import TTLCache
+cache = TTLCache(maxsize=1000, ttl=300)  # 5분
+```
+
+```typescript
+// Node.js (lru-cache)
+import { LRUCache } from 'lru-cache'
+const cache = new LRUCache<string, User>({ max: 1000, ttl: 5 * 60 * 1000 })
+
+async function getUser(id: string): Promise<User> {
+  const cached = cache.get(id)
+  if (cached) return cached
+  const user = await db.user.findUnique({ where: { id } })
+  if (user) cache.set(id, user)
+  return user
+}
+```
+
+```go
+// Go (groupcache / ristretto)
+import "github.com/dgraph-io/ristretto"
+cache, _ := ristretto.NewCache(&ristretto.Config{
+    NumCounters: 1e7, MaxCost: 1 << 30, BufferItems: 64,
+})
+```
+
+```rust
+// Rust (moka)
+use moka::future::Cache;
+let cache: Cache<String, User> = Cache::builder()
+    .max_capacity(1000)
+    .time_to_live(Duration::from_secs(300))
+    .build();
+```
+
+**캐시 전략:** 읽기 빈도 높고, 쓰기 빈도 낮은 데이터에 적용. TTL로 신선도 보장.

package/templates/.claude/skills/project-optimizer/rules/io-connection-reuse.md

@@ -0,0 +1,67 @@
+---
+title: Reuse Connections with Pooling
+impact: HIGH
+impactDescription: Eliminates connection overhead, 5-20x throughput
+tags: io, connection, pool, keep-alive, reuse
+languages: all
+related: [concurrency-pool, memory-pool-reuse]
+---
+
+## 커넥션 풀/재사용
+
+매 요청마다 새 커넥션을 생성하지 않고 풀에서 재사용합니다.
+
+**❌ 잘못된 예시 (매번 새 커넥션):**
+
+```python
+def get_user(user_id):
+    conn = psycopg2.connect(DSN)  # 매번 TCP 핸드셰이크 + TLS + 인증
+    cursor = conn.cursor()
+    cursor.execute("SELECT ...", (user_id,))
+    result = cursor.fetchone()
+    conn.close()
+    return result
+```
+
+**✅ 올바른 예시 (커넥션 풀):**
+
+```python
+# Python (SQLAlchemy)
+engine = create_engine(DSN, pool_size=10, max_overflow=20, pool_recycle=3600)
+
+# Python (asyncpg)
+pool = await asyncpg.create_pool(DSN, min_size=5, max_size=20)
+async with pool.acquire() as conn:
+    result = await conn.fetchrow("SELECT ...", user_id)
+```
+
+```typescript
+// Prisma (자동 풀링)
+// datasource db { url = "..." } → connection_limit 설정
+// schema.prisma: url = "...?connection_limit=10"
+```
+
+```go
+// Go (database/sql - 내장 풀)
+db, _ := sql.Open("postgres", dsn)
+db.SetMaxOpenConns(25)
+db.SetMaxIdleConns(10)
+db.SetConnMaxLifetime(5 * time.Minute)
+```
+
+```rust
+// Rust (deadpool-postgres)
+let pool = Pool::builder(manager).max_size(16).build().unwrap();
+let client = pool.get().await?;
+let rows = client.query("SELECT ...", &[&user_id]).await?;
+```
+
+```java
+// Java (HikariCP)
+HikariConfig config = new HikariConfig();
+config.setMaximumPoolSize(10);
+config.setMinimumIdle(5);
+config.setConnectionTimeout(30000);
+```
+
+**HTTP 커넥션 재사용:** `Keep-Alive` 헤더, HTTP/2 멀티플렉싱, HTTP 클라이언트 인스턴스 재사용.

package/templates/.claude/skills/project-optimizer/rules/io-serialize-minimal.md

@@ -0,0 +1,61 @@
+---
+title: Serialize Only Required Fields
+impact: MEDIUM
+impactDescription: 30-70% payload reduction, faster serialization
+tags: io, serialization, payload, network, select
+languages: all
+related: [io-batch-queries, memory-large-data]
+---
+
+## 필요한 필드만 직렬화/전송
+
+전체 객체 대신 실제 사용하는 필드만 선택하여 직렬화 비용과 네트워크 전송량을 줄입니다.
+
+**❌ 잘못된 예시 (전체 객체 반환):**
+
+```python
+# 50개 필드 전부 전송, 클라이언트는 3개만 사용
+@app.get("/users")
+def list_users():
+    return db.query(User).all()  # password_hash 포함 위험
+```
+
+```typescript
+// 전체 객체 반환
+return await prisma.user.findMany()  // 50개 필드
+```
+
+**✅ 올바른 예시 (필요 필드만):**
+
+```python
+# DTO/스키마로 필드 제한
+@app.get("/users")
+def list_users():
+    users = db.query(User.id, User.name, User.email).all()
+    return [UserResponse(id=u.id, name=u.name, email=u.email) for u in users]
+```
+
+```typescript
+// Prisma select
+const users = await prisma.user.findMany({
+  select: { id: true, name: true, email: true }
+})
+```
+
+```sql
+-- SQL
+SELECT id, name, email FROM users;  -- ✅
+SELECT * FROM users;                -- ❌
+```
+
+```go
+// Go - json 태그로 제어
+type UserResponse struct {
+    ID    string `json:"id"`
+    Name  string `json:"name"`
+    Email string `json:"email"`
+    // PasswordHash 필드 없음 → 자동 제외
+}
+```
+
+**적용 범위:** API 응답, SSR 데이터, 캐시 저장, 메시지 큐 페이로드.

package/templates/.claude/skills/project-optimizer/rules/io-stream.md

@@ -0,0 +1,75 @@
+---
+title: Stream Large Data Instead of Loading All
+impact: HIGH
+impactDescription: Constant memory usage, no OOM on large datasets
+tags: io, streaming, iterator, generator, memory
+languages: all
+related: [memory-large-data, concurrency-pipeline]
+---
+
+## 대용량 데이터 스트리밍 처리
+
+전체 데이터를 메모리에 적재하지 않고 스트림/이터레이터/제너레이터로 청크 단위 처리합니다.
+
+**❌ 잘못된 예시 (전체 로드):**
+
+```python
+# 100만 행 전체 메모리 적재
+rows = db.execute("SELECT * FROM big_table").fetchall()
+for row in rows:
+    process(row)
+```
+
+**✅ 올바른 예시 (스트리밍):**
+
+```python
+# Python - 서버 사이드 커서
+cursor = db.execute("SELECT * FROM big_table")
+while batch := cursor.fetchmany(1000):
+    for row in batch:
+        process(row)
+
+# 파일 스트리밍
+with open("huge.csv") as f:
+    for line in f:  # 한 줄씩 (메모리 일정)
+        process(line)
+```
+
+```typescript
+// Node.js - 스트림
+import { createReadStream } from 'fs'
+import { pipeline } from 'stream/promises'
+
+await pipeline(
+  createReadStream('huge.csv'),
+  new Transform({ transform(chunk, enc, cb) { /* 청크 처리 */ cb() } }),
+  createWriteStream('output.csv')
+)
+```
+
+```go
+// Go - Scanner (파일), rows.Next() (DB)
+scanner := bufio.NewScanner(file)
+for scanner.Scan() {
+    process(scanner.Text())
+}
+
+rows, _ := db.Query("SELECT * FROM big_table")
+defer rows.Close()
+for rows.Next() {
+    var item Item
+    rows.Scan(&item.ID, &item.Name)
+    process(item)
+}
+```
+
+```rust
+// Rust - Iterator (lazy)
+use std::io::{BufRead, BufReader};
+let reader = BufReader::new(file);
+for line in reader.lines() {
+    process(line?);
+}
+```
+
+**적용 기준:** 10MB+ 파일, 10K+ DB 행, API 페이지네이션.

package/templates/.claude/skills/project-optimizer/rules/memory-bounded-cache.md

@@ -0,0 +1,65 @@
+---
+title: Bound Cache Size with LRU/TTL
+impact: MEDIUM
+impactDescription: Prevents unbounded memory growth
+tags: memory, cache, lru, ttl, bounded
+languages: all
+related: [io-cache-layer, concurrency-pool]
+---
+
+## 캐시에 크기 제한 설정
+
+무제한 캐시는 시간이 지남에 따라 메모리를 소진합니다. LRU(최소 최근 사용) + TTL(유효 시간)로 제한합니다.
+
+**❌ 잘못된 예시 (무제한 캐시):**
+
+```python
+cache = {}  # 무제한 성장
+def get_user(id):
+    if id not in cache:
+        cache[id] = db.get_user(id)
+    return cache[id]
+# 100만 유저 → 100만 항목, OOM
+```
+
+**✅ 올바른 예시 (제한된 캐시):**
+
+```python
+# Python
+from cachetools import TTLCache, LRUCache
+cache = TTLCache(maxsize=10000, ttl=300)  # 최대 1만, 5분 TTL
+
+# functools (크기만 제한)
+@lru_cache(maxsize=1000)
+def get_config(key): ...
+```
+
+```typescript
+// Node.js
+import { LRUCache } from 'lru-cache'
+const cache = new LRUCache<string, User>({
+  max: 10000,              // 최대 항목 수
+  ttl: 5 * 60 * 1000,     // 5분
+  maxSize: 50 * 1024 * 1024, // 50MB (선택)
+  sizeCalculation: (v) => JSON.stringify(v).length,
+})
+```
+
+```go
+// Go (ristretto)
+cache, _ := ristretto.NewCache(&ristretto.Config{
+    NumCounters: 1e5,      // 키 추적 수
+    MaxCost:     1 << 26,  // 64MB
+    BufferItems: 64,
+})
+```
+
+```rust
+// Rust (moka)
+let cache: Cache<String, User> = Cache::builder()
+    .max_capacity(10_000)
+    .time_to_live(Duration::from_secs(300))
+    .build();
+```
+
+**원칙:** 캐시 = max 크기 + 만료 정책. 둘 다 없으면 메모리 릭과 같음.

package/templates/.claude/skills/project-optimizer/rules/memory-large-data.md

@@ -0,0 +1,64 @@
+---
+title: Paginate or Stream Large Datasets
+impact: MEDIUM
+impactDescription: Constant memory usage regardless of data size
+tags: memory, pagination, streaming, large-data
+languages: all
+related: [io-stream, concurrency-pipeline]
+---
+
+## 대용량 데이터 페이지네이션/스트리밍
+
+전체 데이터를 한번에 메모리에 적재하지 않고 페이지 단위 또는 스트림으로 처리합니다.
+
+**❌ 잘못된 예시:**
+
+```python
+all_users = db.query("SELECT * FROM users").fetchall()  # 100만 행 = OOM
+response = jsonify(all_users)
+```
+
+**✅ 올바른 예시:**
+
+```python
+# 커서 기반 페이지네이션
+@app.get("/users")
+def list_users(cursor: str = None, limit: int = 50):
+    query = db.query(User).order_by(User.id)
+    if cursor:
+        query = query.filter(User.id > cursor)
+    users = query.limit(limit).all()
+    next_cursor = users[-1].id if users else None
+    return {"data": users, "next_cursor": next_cursor}
+```
+
+```typescript
+// 커서 기반 (Prisma)
+const users = await prisma.user.findMany({
+  take: 50,
+  skip: cursor ? 1 : 0,
+  cursor: cursor ? { id: cursor } : undefined,
+  orderBy: { id: 'asc' },
+})
+```
+
+```go
+// Go - 청크 처리
+const batchSize = 1000
+var lastID int64
+for {
+    var batch []User
+    db.Where("id > ?", lastID).Order("id").Limit(batchSize).Find(&batch)
+    if len(batch) == 0 { break }
+    processBatch(batch)
+    lastID = batch[len(batch)-1].ID
+}
+```
+
+**페이지네이션 유형:**
+
+| 유형 | 장점 | 단점 |
+|------|------|------|
+| **Offset** | 간단 구현 | 대량 데이터 시 느림, 중복/누락 |
+| **Cursor** | 일관성, 빠름 | 임의 페이지 접근 불가 |
+| **Keyset** | 가장 빠름 | 정렬 키 필요 |

package/templates/.claude/skills/project-optimizer/rules/memory-lazy-init.md

@@ -0,0 +1,78 @@
+---
+title: Lazy Initialize Expensive Resources
+impact: MEDIUM
+impactDescription: Faster startup, lower baseline memory
+tags: memory, lazy, initialization, startup
+languages: all
+related: [concurrency-defer-await, build-code-split]
+---
+
+## 비싼 초기화 지연 실행
+
+애플리케이션 시작 시 모든 리소스를 초기화하지 않고, 실제 사용 시점에 지연 초기화합니다.
+
+**❌ 잘못된 예시 (즉시 초기화):**
+
+```python
+# 모듈 import 시 즉시 무거운 ML 모델 로드
+import tensorflow as tf
+model = tf.keras.models.load_model("huge_model.h5")  # 5초, 2GB RAM
+```
+
+```typescript
+// 모듈 로드 시 즉시 초기화
+const heavyConfig = JSON.parse(fs.readFileSync('config.json', 'utf8'))
+const searchIndex = buildSearchIndex(allDocuments)  // 3초
+```
+
+**✅ 올바른 예시 (지연 초기화):**
+
+```python
+# Python - 필요 시점에 로드
+_model = None
+def get_model():
+    global _model
+    if _model is None:
+        import tensorflow as tf
+        _model = tf.keras.models.load_model("huge_model.h5")
+    return _model
+
+# Python 3.8+ functools.cached_property
+class Service:
+    @cached_property
+    def model(self):
+        return load_heavy_model()
+```
+
+```typescript
+// JS/TS - getter 또는 lazy 패턴
+let _searchIndex: SearchIndex | null = null
+function getSearchIndex(): SearchIndex {
+  if (!_searchIndex) {
+    _searchIndex = buildSearchIndex(allDocuments)
+  }
+  return _searchIndex
+}
+```
+
+```rust
+// Rust - LazyLock (std) 또는 once_cell
+use std::sync::LazyLock;
+static CONFIG: LazyLock<Config> = LazyLock::new(|| {
+    load_config().expect("config load failed")
+});
+```
+
+```go
+// Go - sync.Once
+var (
+    instance *Service
+    once     sync.Once
+)
+func GetService() *Service {
+    once.Do(func() { instance = newService() })
+    return instance
+}
+```
+
+**적용 대상:** ML 모델, 검색 인덱스, 대용량 설정, 외부 서비스 커넥션.