@kood/claude-code 0.6.6 → 0.7.0

package/templates/.claude/skills/project-optimizer/rules/build-incremental.md

@@ -0,0 +1,65 @@
+---
+title: Enable Incremental Builds
+impact: CRITICAL
+impactDescription: 50-90% build time reduction on repeat builds
+tags: build, incremental, cache, compile
+languages: all
+related: [build-cache, dx-ci-speed]
+---
+
+## 증분 빌드 활성화
+
+전체 재빌드 대신 변경된 파일만 컴파일하여 빌드 시간을 대폭 줄입니다.
+
+**❌ 잘못된 예시 (매번 전체 빌드):**
+
+```json
+// tsconfig.json - incremental 비활성화
+{ "compilerOptions": { "incremental": false } }
+```
+
+```toml
+# Cargo.toml - release에서 증분 비활성화
+[profile.release]
+incremental = false
+```
+
+**✅ 올바른 예시:**
+
+```json
+// TypeScript
+{ "compilerOptions": { "incremental": true, "tsBuildInfoFile": ".tsbuildinfo" } }
+```
+
+```toml
+# Rust
+[profile.dev]
+incremental = true
+```
+
+```python
+# Python (mypy)
+[tool.mypy]
+incremental = true
+cache_dir = ".mypy_cache"
+```
+
+```gradle
+// Gradle
+org.gradle.caching=true
+org.gradle.parallel=true
+```
+
+```yaml
+# CI 캐시 (GitHub Actions)
+- uses: actions/cache@v4
+  with:
+    path: |
+      node_modules/.cache
+      .tsbuildinfo
+      target/
+      ~/.cargo/registry
+    key: ${{ runner.os }}-build-${{ hashFiles('**/lockfile') }}
+```
+
+**효과:** TypeScript 50-70% 감소, Rust dev 40-60% 감소, Gradle 30-50% 감소.

package/templates/.claude/skills/project-optimizer/rules/build-minify.md

@@ -0,0 +1,61 @@
+---
+title: Minify and Compress Production Output
+impact: HIGH
+impactDescription: 30-50% output size reduction
+tags: build, minify, compression, production
+languages: [js, ts, css]
+related: [build-tree-shake, build-code-split]
+---
+
+## 프로덕션 출력 최소화
+
+프로덕션 빌드에서 minification, compression을 활성화하여 배포 크기를 줄입니다.
+
+**✅ 올바른 예시:**
+
+```typescript
+// Vite
+export default defineConfig({
+  build: {
+    minify: 'terser',  // 또는 'esbuild' (빠름)
+    cssMinify: true,
+    rollupOptions: {
+      output: { manualChunks: { vendor: ['react', 'react-dom'] } }
+    }
+  }
+})
+```
+
+```toml
+# Rust
+[profile.release]
+opt-level = "z"       # 크기 최적화 (또는 "3" 속도 최적화)
+lto = "thin"          # LTO
+strip = "symbols"
+panic = "abort"       # unwind 코드 제거
+codegen-units = 1     # 최적화 극대화 (빌드 느려짐)
+```
+
+```go
+// Go
+// go build -ldflags="-s -w" -trimpath ./cmd/app
+// -s: 심볼 테이블 제거, -w: DWARF 제거, -trimpath: 경로 정보 제거
+```
+
+```dockerfile
+# Docker 멀티스테이지 빌드
+FROM golang:1.22 AS builder
+RUN CGO_ENABLED=0 go build -ldflags="-s -w" -o /app
+
+FROM scratch
+COPY --from=builder /app /app
+ENTRYPOINT ["/app"]
+```
+
+**서버 압축:**
+
+| 방법 | 감소율 | 도구 |
+|------|--------|------|
+| gzip | ~70% | Nginx, CDN 기본 |
+| Brotli | ~80% | Nginx, Cloudflare |
+| 빌드 시 사전 압축 | 서버 CPU 절약 | `vite-plugin-compression` |

package/templates/.claude/skills/project-optimizer/rules/build-tree-shake.md

@@ -0,0 +1,60 @@
+---
+title: Enable Tree Shaking / Dead Code Elimination
+impact: CRITICAL
+impactDescription: 20-60% bundle size reduction
+tags: build, tree-shaking, dead-code, bundle-size
+languages: [js, ts, rust, go]
+related: [build-code-split, code-dead-elimination, deps-unused-removal]
+---
+
+## 미사용 코드 자동 제거
+
+번들러/컴파일러의 dead code elimination을 활성화하여 실제 사용하는 코드만 출력에 포함합니다.
+
+**❌ 잘못된 예시:**
+
+```json
+// package.json - sideEffects 미지정
+{ "name": "my-lib" }
+// 번들러가 어떤 코드가 부작용 있는지 몰라서 전부 포함
+```
+
+```typescript
+// 배럴 파일에서 전체 import
+import { oneUtil } from './utils'  // utils/index.ts가 50개 모듈 re-export
+```
+
+**✅ 올바른 예시:**
+
+```json
+// package.json - sideEffects 지정
+{ "name": "my-lib", "sideEffects": false }
+// 또는 특정 파일만: "sideEffects": ["*.css", "./src/polyfill.js"]
+```
+
+```typescript
+// 직접 import (배럴 파일 우회)
+import { oneUtil } from './utils/oneUtil'
+```
+
+```toml
+# Rust - release 최적화
+[profile.release]
+lto = "thin"          # Link-Time Optimization
+strip = "symbols"     # 심볼 제거
+opt-level = "z"       # 크기 최적화
+```
+
+```go
+// Go - 기본 활성화. 추가 최적화:
+// go build -ldflags="-s -w"  # 심볼 테이블, DWARF 디버그 정보 제거
+```
+
+**도구별 설정:**
+
+| 빌드 도구 | 설정 |
+|-----------|------|
+| Vite/Rollup | 기본 활성화 (`build.rollupOptions`) |
+| webpack | `mode: 'production'`, `usedExports: true` |
+| esbuild | `--tree-shaking=true` (기본) |
+| tsup | `treeshake: true` |

package/templates/.claude/skills/project-optimizer/rules/code-complexity.md

@@ -0,0 +1,65 @@
+---
+title: Reduce Cyclomatic Complexity
+impact: MEDIUM
+impactDescription: Easier testing, fewer bugs, better readability
+tags: code, complexity, early-return, guard-clause, extract
+languages: all
+related: [code-duplication, code-error-handling]
+---
+
+## 순환 복잡도 감소
+
+깊은 중첩, 긴 if-else 체인, 복잡한 조건문을 단순화합니다.
+
+**❌ 잘못된 예시 (깊은 중첩):**
+
+```python
+def process(request):
+    if request:
+        if request.user:
+            if request.user.is_active:
+                if request.data:
+                    return do_work(request.data)
+                else:
+                    return Error("no data")
+            else:
+                return Error("inactive")
+        else:
+            return Error("no user")
+    else:
+        return Error("no request")
+```
+
+**✅ 올바른 예시 (guard clause + early return):**
+
+```python
+def process(request):
+    if not request:
+        return Error("no request")
+    if not request.user:
+        return Error("no user")
+    if not request.user.is_active:
+        return Error("inactive")
+    if not request.data:
+        return Error("no data")
+    return do_work(request.data)
+```
+
+**✅ 올바른 예시 (table-driven):**
+
+```python
+# ❌ 긴 if-else 체인
+def get_discount(tier):
+    if tier == "bronze": return 0.05
+    elif tier == "silver": return 0.10
+    elif tier == "gold": return 0.15
+    elif tier == "platinum": return 0.20
+    else: return 0
+
+# ✅ 맵/딕셔너리
+DISCOUNTS = {"bronze": 0.05, "silver": 0.10, "gold": 0.15, "platinum": 0.20}
+def get_discount(tier):
+    return DISCOUNTS.get(tier, 0)
+```
+
+**목표:** 함수당 순환 복잡도 10 이하, 중첩 깊이 3 이하.

package/templates/.claude/skills/project-optimizer/rules/code-dead-elimination.md

@@ -0,0 +1,32 @@
+---
+title: Remove Dead Code and Unused Imports
+impact: MEDIUM-HIGH
+impactDescription: Cleaner codebase, smaller bundles, faster comprehension
+tags: code, dead-code, unused, imports, cleanup
+languages: all
+related: [build-tree-shake, deps-unused-removal]
+---
+
+## 미사용 코드/변수/import 제거
+
+사용되지 않는 코드는 혼란을 주고 번들 크기를 증가시킵니다. 도구로 감지하고 즉시 제거합니다.
+
+**감지 도구:**
+
+| 언어 | 도구 | 명령어 |
+|------|------|--------|
+| **JS/TS** | `knip` | `npx knip` |
+| **JS/TS** | ESLint `no-unused-vars` | 자동 |
+| **Python** | `vulture` | `vulture src/` |
+| **Python** | `autoflake` | `autoflake --remove-all-unused-imports` |
+| **Go** | 컴파일러 (내장) | 미사용 import/변수 = 컴파일 에러 |
+| **Rust** | 컴파일러 (내장) | `#[warn(dead_code)]` 기본 활성화 |
+| **Java** | IntelliJ / SonarQube | 자동 감지 |
+
+**제거 대상:**
+- 미사용 import/require
+- 미사용 변수/상수
+- 호출되지 않는 함수/메서드
+- 도달 불가능한 코드 (unreachable after return/throw)
+- 주석 처리된 코드 블록 (Git 히스토리에 보존됨)
+- 미사용 타입/인터페이스 정의

package/templates/.claude/skills/project-optimizer/rules/code-duplication.md

@@ -0,0 +1,54 @@
+---
+title: Extract Duplicated Code (Rule of Three)
+impact: MEDIUM
+impactDescription: Reduced maintenance burden, single source of truth
+tags: code, duplication, dry, extract, refactor
+languages: all
+related: [code-complexity, arch-interface-segregation]
+---
+
+## 중복 코드 추출 (3회 이상부터)
+
+동일/유사 코드가 3회 이상 반복되면 함수/모듈로 추출합니다. 2회까지는 허용 (premature abstraction 방지).
+
+**❌ 잘못된 예시 (3곳에서 반복):**
+
+```python
+# file_a.py
+data = json.loads(response.text)
+if "error" in data:
+    logger.error(f"API error: {data['error']}")
+    raise ApiError(data["error"])
+
+# file_b.py (동일 패턴 반복)
+data = json.loads(response.text)
+if "error" in data:
+    logger.error(f"API error: {data['error']}")
+    raise ApiError(data["error"])
+```
+
+**✅ 올바른 예시 (추출):**
+
+```python
+# utils/api.py
+def parse_api_response(response: Response) -> dict:
+    data = response.json()
+    if "error" in data:
+        logger.error(f"API error: {data['error']}")
+        raise ApiError(data["error"])
+    return data
+
+# file_a.py, file_b.py
+data = parse_api_response(response)
+```
+
+**감지 도구:**
+
+| 언어 | 도구 |
+|------|------|
+| **범용** | `jscpd` (Copy/Paste Detector) |
+| **Python** | `pylint --disable=all --enable=duplicate-code` |
+| **Java** | PMD CPD |
+| **Go** | `dupl` |
+
+**주의:** 비슷해 보이지만 다른 의도의 코드는 추출하지 않음. 추상화 비용 > 중복 비용이면 중복 허용.

package/templates/.claude/skills/project-optimizer/rules/code-error-handling.md

@@ -0,0 +1,75 @@
+---
+title: Consistent Error Handling Pattern
+impact: MEDIUM
+impactDescription: Predictable error flow, easier debugging
+tags: code, error, exception, result, handling
+languages: all
+related: [code-complexity, memory-leak-prevention]
+---
+
+## 일관된 에러 처리 패턴
+
+프로젝트 전체에서 하나의 에러 처리 패턴을 일관되게 사용합니다.
+
+**언어별 권장 패턴:**
+
+| 언어 | 패턴 | 핵심 |
+|------|------|------|
+| **Go** | `(value, error)` | 항상 err 체크, sentinel errors |
+| **Rust** | `Result<T, E>` | `?` 연산자, 커스텀 Error enum |
+| **Python** | Exception 계층 | 커스텀 Exception, `raise from` |
+| **JS/TS** | 커스텀 Error / Result | Error 서브클래스 또는 Result 타입 |
+| **Java** | Unchecked 선호 | RuntimeException 서브클래스 |
+
+**✅ 올바른 예시:**
+
+```typescript
+// JS/TS - 커스텀 Error 클래스
+class AppError extends Error {
+  constructor(
+    message: string,
+    public code: string,
+    public statusCode: number = 500
+  ) {
+    super(message)
+    this.name = 'AppError'
+  }
+}
+class NotFoundError extends AppError {
+  constructor(resource: string) {
+    super(`${resource} not found`, 'NOT_FOUND', 404)
+  }
+}
+```
+
+```go
+// Go - sentinel errors + wrapping
+var ErrNotFound = errors.New("not found")
+var ErrUnauthorized = errors.New("unauthorized")
+
+func getUser(id string) (*User, error) {
+    user, err := db.Find(id)
+    if err != nil {
+        return nil, fmt.Errorf("getUser(%s): %w", id, err)
+    }
+    if user == nil {
+        return nil, ErrNotFound
+    }
+    return user, nil
+}
+```
+
+```rust
+// Rust - thiserror
+#[derive(Debug, thiserror::Error)]
+enum AppError {
+    #[error("not found: {0}")]
+    NotFound(String),
+    #[error("unauthorized")]
+    Unauthorized,
+    #[error(transparent)]
+    Database(#[from] sqlx::Error),
+}
+```
+
+**원칙:** 에러는 발생 지점에서 컨텍스트를 추가하고, 처리 지점에서 변환/로깅합니다.

package/templates/.claude/skills/project-optimizer/rules/code-naming.md

@@ -0,0 +1,52 @@
+---
+title: Use Intent-Revealing Names
+impact: MEDIUM
+impactDescription: Self-documenting code, reduced cognitive load
+tags: code, naming, readability, maintainability
+languages: all
+related: [code-complexity, dx-type-safety]
+---
+
+## 의도를 드러내는 이름 사용
+
+변수/함수/클래스 이름만으로 역할과 의도를 파악할 수 있게 합니다.
+
+**❌ 잘못된 예시:**
+
+```python
+d = {}          # 무엇의 딕셔너리?
+tmp = get()     # 임시? 무엇을 가져옴?
+flag = True     # 어떤 플래그?
+def proc(x):    # 무엇을 처리?
+    pass
+
+for i in lst:   # i와 lst가 무엇?
+    if i.s == 1:  # s가 무엇? 1이 무엇?
+        do(i)
+```
+
+**✅ 올바른 예시:**
+
+```python
+user_scores = {}
+active_user = get_current_user()
+is_premium = True
+def calculate_shipping_cost(order):
+    pass
+
+STATUS_ACTIVE = 1
+for user in users:
+    if user.status == STATUS_ACTIVE:
+        send_notification(user)
+```
+
+**명명 패턴:**
+
+| 유형 | 패턴 | 예시 |
+|------|------|------|
+| **Boolean** | `is_`, `has_`, `can_`, `should_` | `is_valid`, `has_permission` |
+| **함수** | 동사 + 목적어 | `calculate_total`, `send_email` |
+| **컬렉션** | 복수형 | `users`, `order_items` |
+| **맵/딕셔너리** | `x_by_y` | `user_by_id`, `orders_by_date` |
+| **상수** | `UPPER_SNAKE` | `MAX_RETRY_COUNT` |
+| **축약 금지** | 풀네임 사용 | `transaction` (not `txn`) |

package/templates/.claude/skills/project-optimizer/rules/concurrency-defer-await.md

@@ -0,0 +1,54 @@
+---
+title: Defer Await to Point of Use
+impact: CRITICAL
+impactDescription: Eliminates unnecessary blocking, enables overlap
+tags: concurrency, async, await, deferred
+languages: all
+related: [concurrency-parallel, memory-lazy-init]
+---
+
+## await/블로킹을 사용 지점으로 이동
+
+비동기 작업의 결과를 기다리는 시점을 실제 사용 지점으로 미뤄서, 그 사이에 다른 작업이 실행될 수 있게 합니다.
+
+**❌ 잘못된 예시 (즉시 대기):**
+
+```typescript
+// 결과가 10줄 뒤에서 필요한데 즉시 await
+const data = await fetchData()
+// ... 다른 동기 작업 10줄 ...
+processData(data)
+```
+
+```python
+data = await fetch_data()  # 여기서 블로킹
+# ... 다른 동기 작업 ...
+process_data(data)
+```
+
+**✅ 올바른 예시 (사용 시점에서 대기):**
+
+```typescript
+// Promise를 먼저 시작, 나중에 await
+const dataPromise = fetchData()  // 시작만 함
+// ... 다른 동기 작업 (이 동안 fetch 진행) ...
+const data = await dataPromise   // 실제 필요 시점에 await
+processData(data)
+```
+
+```python
+import asyncio
+task = asyncio.create_task(fetch_data())  # 시작만 함
+# ... 다른 동기 작업 ...
+data = await task  # 실제 필요 시점에 await
+process_data(data)
+```
+
+```go
+ch := make(chan *Data, 1)
+go func() { ch <- fetchData(ctx) }()  // 시작
+// ... 다른 작업 ...
+data := <-ch  // 실제 필요 시점에 수신
+```
+
+**핵심:** 작업 시작과 결과 소비 사이에 다른 유용한 작업이 있으면 defer 적용.

package/templates/.claude/skills/project-optimizer/rules/concurrency-parallel.md

@@ -0,0 +1,90 @@
+---
+title: Parallelize Independent Operations
+impact: CRITICAL
+impactDescription: 2-10x improvement on I/O-bound workloads
+tags: concurrency, parallelization, async, performance
+languages: all
+related: [concurrency-defer-await, concurrency-pool, io-batch-queries]
+---
+
+## 독립 작업 병렬 실행
+
+서로 의존성이 없는 I/O 작업은 동시에 실행하여 총 대기 시간을 최장 작업 1개 수준으로 줄입니다.
+
+**❌ 잘못된 예시 (순차 실행, 3번 왕복):**
+
+```typescript
+// JS/TS
+const user = await fetchUser()
+const posts = await fetchPosts()
+const comments = await fetchComments()
+// 총 시간: T(user) + T(posts) + T(comments)
+```
+
+```python
+# Python
+user = await fetch_user()
+posts = await fetch_posts()
+comments = await fetch_comments()
+```
+
+```go
+// Go
+user, _ := fetchUser(ctx)
+posts, _ := fetchPosts(ctx)
+comments, _ := fetchComments(ctx)
+```
+
+**✅ 올바른 예시 (병렬 실행, 1번 왕복):**
+
+```typescript
+// JS/TS
+const [user, posts, comments] = await Promise.all([
+  fetchUser(), fetchPosts(), fetchComments()
+])
+// 총 시간: max(T(user), T(posts), T(comments))
+```
+
+```python
+# Python
+user, posts, comments = await asyncio.gather(
+    fetch_user(), fetch_posts(), fetch_comments()
+)
+```
+
+```go
+// Go (errgroup)
+g, ctx := errgroup.WithContext(ctx)
+var user *User; var posts []Post; var comments []Comment
+g.Go(func() error { var err error; user, err = fetchUser(ctx); return err })
+g.Go(func() error { var err error; posts, err = fetchPosts(ctx); return err })
+g.Go(func() error { var err error; comments, err = fetchComments(ctx); return err })
+if err := g.Wait(); err != nil { return err }
+```
+
+```rust
+// Rust (tokio)
+let (user, posts, comments) = tokio::try_join!(
+    fetch_user(), fetch_posts(), fetch_comments()
+)?;
+```
+
+```java
+// Java
+var userFuture = CompletableFuture.supplyAsync(() -> fetchUser());
+var postsFuture = CompletableFuture.supplyAsync(() -> fetchPosts());
+CompletableFuture.allOf(userFuture, postsFuture).join();
+var user = userFuture.get();
+var posts = postsFuture.get();
+```
+
+```csharp
+// C#
+var userTask = FetchUserAsync();
+var postsTask = FetchPostsAsync();
+await Task.WhenAll(userTask, postsTask);
+var user = userTask.Result;
+var posts = postsTask.Result;
+```
+
+**적용 기준:** 두 작업이 서로의 결과를 필요로 하지 않으면 병렬화 대상.

package/templates/.claude/skills/project-optimizer/rules/concurrency-pipeline.md

@@ -0,0 +1,68 @@
+---
+title: Pipeline Parallelization
+impact: HIGH
+impactDescription: Continuous throughput for multi-stage processing
+tags: concurrency, pipeline, streaming, producer-consumer
+languages: all
+related: [concurrency-parallel, io-stream, memory-large-data]
+---
+
+## 파이프라인 병렬화
+
+다단계 처리에서 각 단계를 동시에 실행하여 처리량을 극대화합니다. 한 단계의 출력이 다음 단계의 입력이 되는 스트리밍 방식.
+
+**❌ 잘못된 예시 (단계별 전체 처리):**
+
+```python
+# 모든 데이터를 한 단계 완료 후 다음 단계
+items = fetch_all()           # 10초 대기
+processed = [process(i) for i in items]  # 10초 대기
+results = [save(p) for p in processed]   # 10초 대기
+# 총 30초, 메모리에 전체 데이터 적재
+```
+
+**✅ 올바른 예시 (스트리밍 파이프라인):**
+
+```python
+# Python (async generator)
+async def fetch_stream():
+    async for item in db.stream_query("SELECT ..."):
+        yield item
+
+async def process_stream(items):
+    async for item in items:
+        yield transform(item)
+
+async def save_stream(items):
+    batch = []
+    async for item in items:
+        batch.append(item)
+        if len(batch) >= 100:
+            await db.bulk_insert(batch)
+            batch.clear()
+    if batch:
+        await db.bulk_insert(batch)
+
+# 파이프라인 연결
+await save_stream(process_stream(fetch_stream()))
+```
+
+```go
+// Go (channel pipeline)
+func fetch(ctx context.Context) <-chan Item {
+    out := make(chan Item, 100)
+    go func() { defer close(out); /* fetch and send */ }()
+    return out
+}
+
+func process(in <-chan Item) <-chan Result {
+    out := make(chan Result, 100)
+    go func() { defer close(out); for item := range in { out <- transform(item) } }()
+    return out
+}
+
+// 파이프라인 연결
+results := process(fetch(ctx))
+```
+
+**적용 기준:** 데이터가 대량이고 단계별로 독립 처리 가능할 때.