@kood/claude-code 0.6.6 → 0.6.7

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 모델, 검색 인덱스, 대용량 설정, 외부 서비스 커넥션.

package/templates/.claude/skills/project-optimizer/rules/memory-leak-prevention.md

@@ -0,0 +1,79 @@
+---
+title: Guarantee Resource Cleanup
+impact: HIGH
+impactDescription: Prevents memory leaks, file handle exhaustion, connection leaks
+tags: memory, resource, leak, cleanup, dispose
+languages: all
+related: [memory-pool-reuse, io-connection-reuse]
+---
+
+## 리소스 해제 보장
+
+파일, DB 커넥션, 소켓, 락 등 시스템 리소스는 예외 발생 시에도 반드시 해제합니다.
+
+**❌ 잘못된 예시:**
+
+```python
+f = open("data.csv")
+data = f.read()  # 예외 시 f.close() 호출 안 됨
+
+conn = db.connect()
+result = conn.execute(query)  # 예외 시 커넥션 누수
+```
+
+**✅ 올바른 예시:**
+
+```python
+# Python - context manager
+with open("data.csv") as f:
+    data = f.read()
+
+async with pool.acquire() as conn:
+    result = await conn.execute(query)
+```
+
+```go
+// Go - defer
+resp, err := http.Get(url)
+if err != nil { return err }
+defer resp.Body.Close()
+
+f, err := os.Open("data.csv")
+if err != nil { return err }
+defer f.Close()
+```
+
+```typescript
+// JS/TS - try/finally
+const conn = await pool.acquire()
+try {
+  return await conn.query(sql)
+} finally {
+  conn.release()
+}
+
+// TC39 Explicit Resource Management (using)
+await using conn = await pool.acquire()
+return await conn.query(sql)
+```
+
+```rust
+// Rust - RAII (자동)
+let file = File::open("data.csv")?;  // Drop trait으로 스코프 끝에서 자동 해제
+let data = read_to_string(&file)?;
+// file 자동 해제
+```
+
+```java
+// Java - try-with-resources
+try (var conn = dataSource.getConnection();
+     var stmt = conn.prepareStatement(sql)) {
+    return stmt.executeQuery();
+}
+```
+
+```csharp
+// C# - using
+await using var conn = await pool.GetConnectionAsync();
+return await conn.QueryAsync(sql);
+```

package/templates/.claude/skills/project-optimizer/rules/memory-pool-reuse.md

@@ -0,0 +1,70 @@
+---
+title: Pool and Reuse Expensive Objects
+impact: MEDIUM
+impactDescription: Reduces GC pressure, allocation overhead
+tags: memory, pool, reuse, allocation, gc
+languages: all
+related: [memory-leak-prevention, concurrency-pool, io-connection-reuse]
+---
+
+## 비싼 객체 풀링/재사용
+
+반복 생성-소멸되는 비싼 객체(버퍼, 커넥션, HTTP 클라이언트)를 풀에서 재사용합니다.
+
+**❌ 잘못된 예시:**
+
+```go
+// 매 요청마다 새 버퍼 할당
+func handler(w http.ResponseWriter, r *http.Request) {
+    buf := make([]byte, 32*1024)  // 32KB 매번 할당 + GC
+    io.CopyBuffer(w, r.Body, buf)
+}
+```
+
+```python
+# 매번 새 HTTP 세션
+def fetch(url):
+    return requests.get(url)  # 매번 새 커넥션
+```
+
+**✅ 올바른 예시:**
+
+```go
+// Go - sync.Pool
+var bufPool = sync.Pool{
+    New: func() any { return make([]byte, 32*1024) },
+}
+
+func handler(w http.ResponseWriter, r *http.Request) {
+    buf := bufPool.Get().([]byte)
+    defer bufPool.Put(buf)
+    io.CopyBuffer(w, r.Body, buf)
+}
+```
+
+```python
+# Python - 세션 재사용
+session = requests.Session()  # 모듈 레벨에서 한 번 생성
+
+def fetch(url):
+    return session.get(url)  # 커넥션 재사용, Keep-Alive
+```
+
+```typescript
+// Node.js - HTTP Agent 재사용
+import { Agent } from 'undici'
+const agent = new Agent({ connections: 10, keepAliveTimeout: 30_000 })
+
+// 또는 전역 fetch에서 agent 사용
+```
+
+```rust
+// Rust - 정적 클라이언트
+use reqwest::Client;
+use std::sync::LazyLock;
+static CLIENT: LazyLock<Client> = LazyLock::new(|| {
+    Client::builder().pool_max_idle_per_host(10).build().unwrap()
+});
+```
+
+**적용 대상:** HTTP 클라이언트, DB 커넥션, 버퍼, 정규식 컴파일 결과, 시리얼라이저 인스턴스.