@kood/claude-code 0.6.5 → 0.6.7

package/templates/.claude/skills/project-optimizer/rules/arch-config-centralize.md

@@ -0,0 +1,66 @@
+---
+title: Centralize Configuration and Environment Variables
+impact: LOW-MEDIUM
+impactDescription: Single source of truth, easier deployment management
+tags: arch, config, env, centralize, validation
+languages: all
+related: [code-error-handling, dx-type-safety]
+---
+
+## 설정/환경변수 중앙 관리
+
+코드 전체에 흩어진 `process.env`, `os.environ` 접근을 하나의 설정 모듈로 통합합니다.
+
+**❌ 잘못된 예시 (분산된 환경변수 접근):**
+
+```typescript
+// file_a.ts
+const dbUrl = process.env.DATABASE_URL!  // 누락 시 런타임 에러
+
+// file_b.ts
+const port = parseInt(process.env.PORT || '3000')  // 중복 파싱
+
+// file_c.ts
+if (process.env.NODE_ENV === 'production') { ... }
+```
+
+**✅ 올바른 예시 (중앙 관리):**
+
+```typescript
+// config.ts - 단일 설정 모듈
+import { z } from 'zod'
+
+const envSchema = z.object({
+  DATABASE_URL: z.string().url(),
+  PORT: z.coerce.number().default(3000),
+  NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
+})
+
+export const config = envSchema.parse(process.env)
+// 시작 시 검증, 누락/잘못된 값 즉시 감지
+```
+
+```python
+# Python (pydantic-settings)
+from pydantic_settings import BaseSettings
+
+class Config(BaseSettings):
+    database_url: str
+    port: int = 3000
+    debug: bool = False
+
+config = Config()  # .env + 환경변수 자동 로드
+```
+
+```go
+// Go (envconfig)
+type Config struct {
+    DatabaseURL string `envconfig:"DATABASE_URL" required:"true"`
+    Port        int    `envconfig:"PORT" default:"3000"`
+}
+
+var cfg Config
+envconfig.Process("", &cfg)
+```
+
+**원칙:** 환경변수는 애플리케이션 시작 시 한 번 파싱/검증하고, 이후 타입 안전한 config 객체로 접근.

package/templates/.claude/skills/project-optimizer/rules/arch-hot-path.md

@@ -0,0 +1,35 @@
+---
+title: Identify and Optimize Hot Paths
+impact: LOW-MEDIUM
+impactDescription: Targeted optimization on code that matters most
+tags: arch, hot-path, profiling, optimization, bottleneck
+languages: all
+related: [concurrency-parallel, io-batch-queries, memory-pool-reuse]
+---
+
+## 핫 패스 식별 및 집중 최적화
+
+전체 코드의 80%는 최적화 불필요. 실행 빈도가 높은 20% (핫 패스)를 프로파일링으로 식별하고 집중 최적화합니다.
+
+**프로파일링 도구:**
+
+| 언어 | 도구 | 명령어 |
+|------|------|--------|
+| **JS/TS** | Node.js `--prof` | `node --prof app.js` + `node --prof-process` |
+| **JS/TS** | Chrome DevTools | Performance 탭 |
+| **Python** | cProfile / py-spy | `python -m cProfile -s cumtime app.py` |
+| **Go** | pprof (내장) | `go tool pprof http://localhost:6060/debug/pprof/profile` |
+| **Rust** | flamegraph | `cargo flamegraph` |
+| **Java** | async-profiler | `-agentpath:libasyncProfiler.so` |
+
+**최적화 순서:**
+
+```
+1. 측정 (프로파일링) → 핫 패스 식별
+2. 알고리즘 개선 (O(n²) → O(n log n))
+3. I/O 최적화 (이 스킬의 io-* 규칙 적용)
+4. 메모리 최적화 (이 스킬의 memory-* 규칙 적용)
+5. 마이크로 최적화 (마지막 수단)
+```
+
+**원칙:** "추측하지 말고, 측정하라." 프로파일링 없는 최적화는 시간 낭비. 핫 패스가 아닌 코드의 최적화는 ROI가 낮음.

package/templates/.claude/skills/project-optimizer/rules/arch-interface-segregation.md

@@ -0,0 +1,51 @@
+---
+title: Segregate Large Interfaces
+impact: LOW-MEDIUM
+impactDescription: Reduced coupling, easier testing and mocking
+tags: arch, interface, segregation, coupling
+languages: [ts, go, rust, java, csharp]
+related: [arch-module-boundary, code-duplication]
+---
+
+## 큰 인터페이스를 작은 단위로 분리
+
+하나의 거대한 인터페이스 대신 용도별 작은 인터페이스를 사용합니다.
+
+**❌ 잘못된 예시:**
+
+```typescript
+interface UserService {
+  getUser(id: string): User
+  createUser(data: CreateUserData): User
+  deleteUser(id: string): void
+  sendEmail(userId: string, subject: string): void
+  generateReport(userId: string): Report
+  uploadAvatar(userId: string, file: File): string
+}
+// 이메일만 보내려는 컴포넌트도 전체 인터페이스에 의존
+```
+
+**✅ 올바른 예시:**
+
+```typescript
+interface UserReader { getUser(id: string): User }
+interface UserWriter { createUser(data: CreateUserData): User; deleteUser(id: string): void }
+interface EmailSender { sendEmail(userId: string, subject: string): void }
+// 각 소비자는 필요한 인터페이스만 의존
+```
+
+```go
+// Go - 암시적 인터페이스 (소비자 쪽에서 정의)
+// reader.go - 이 패키지에서 필요한 것만 정의
+type UserGetter interface {
+    GetUser(ctx context.Context, id string) (*User, error)
+}
+```
+
+```rust
+// Rust - trait 분리
+trait Readable { fn read(&self, id: &str) -> Result<User>; }
+trait Writable { fn write(&self, user: &User) -> Result<()>; }
+```
+
+**원칙:** "클라이언트는 자신이 사용하지 않는 메서드에 의존하지 않아야 한다" (ISP).

package/templates/.claude/skills/project-optimizer/rules/arch-module-boundary.md

@@ -0,0 +1,42 @@
+---
+title: Enforce Clear Module Boundaries
+impact: LOW-MEDIUM
+impactDescription: Prevents spaghetti dependencies, enables parallel work
+tags: arch, module, boundary, circular, dependency
+languages: all
+related: [arch-interface-segregation, code-complexity]
+---
+
+## 모듈 경계 명확화
+
+모듈 간 순환 의존을 제거하고 명확한 의존 방향을 유지합니다.
+
+**순환 의존 감지:**
+
+| 언어 | 도구 |
+|------|------|
+| **JS/TS** | `madge --circular src/` |
+| **Python** | `pydeps --no-show` |
+| **Go** | 컴파일러 (순환 import = 컴파일 에러) |
+| **Rust** | 컴파일러 (순환 crate = 컴파일 에러) |
+| **Java** | ArchUnit, JDepend |
+
+**해결 패턴:**
+
+```
+❌ 순환: A → B → C → A
+
+✅ 의존성 역전:
+A → Interface ← B → C
+(A는 인터페이스에 의존, B가 구현)
+
+✅ 이벤트/메시지:
+A → EventBus ← B
+(A가 이벤트 발행, B가 구독)
+
+✅ 추출:
+A → D ← B → C
+(공통 부분을 D로 추출)
+```
+
+**원칙:** 의존 방향은 상위(추상) → 하위(구체). 도메인 모듈이 인프라에 의존하지 않음.

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

@@ -0,0 +1,57 @@
+---
+title: Leverage Build Cache in CI and Local
+impact: HIGH
+impactDescription: 40-80% CI pipeline time reduction
+tags: build, cache, ci, pipeline
+languages: all
+related: [build-incremental, dx-ci-speed]
+---
+
+## 빌드 캐시 활용
+
+CI와 로컬 환경에서 빌드 아티팩트, 의존성, 컴파일 캐시를 재사용합니다.
+
+**✅ GitHub Actions 캐시:**
+
+```yaml
+# Node.js
+- uses: actions/cache@v4
+  with:
+    path: node_modules
+    key: node-${{ hashFiles('yarn.lock') }}
+
+# Rust
+- uses: actions/cache@v4
+  with:
+    path: |
+      ~/.cargo/registry
+      ~/.cargo/git
+      target
+    key: rust-${{ hashFiles('Cargo.lock') }}
+
+# Go
+- uses: actions/cache@v4
+  with:
+    path: |
+      ~/go/pkg/mod
+      ~/.cache/go-build
+    key: go-${{ hashFiles('go.sum') }}
+
+# Python
+- uses: actions/cache@v4
+  with:
+    path: ~/.cache/pip
+    key: pip-${{ hashFiles('requirements.txt') }}
+```
+
+**모노레포 캐시 도구:**
+
+| 도구 | 특징 |
+|------|------|
+| **Turborepo** | 원격 캐시, 태스크 그래프 |
+| **Nx** | 영향 받은 프로젝트만 빌드 |
+| **Bazel** | 세밀한 캐시, 원격 실행 |
+| **sccache** | Rust/C/C++ 컴파일 캐시 |
+| **ccache** | C/C++ 컴파일 캐시 |
+
+**핵심:** 캐시 키에 lockfile 해시 포함, 의존성 변경 시에만 캐시 무효화.

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

@@ -0,0 +1,56 @@
+---
+title: Code Splitting by Entry Point
+impact: HIGH
+impactDescription: 30-70% initial load reduction
+tags: build, code-splitting, lazy-loading, bundle
+languages: [js, ts]
+related: [build-tree-shake, memory-lazy-init]
+---
+
+## 진입점/라우트별 코드 분할
+
+단일 거대 번들 대신 진입점/라우트/기능별로 분할하여 초기 로딩 크기를 줄입니다.
+
+**❌ 잘못된 예시 (단일 번들):**
+
+```typescript
+// 모든 페이지가 하나의 번들에 포함
+import { Dashboard } from './pages/Dashboard'
+import { Settings } from './pages/Settings'
+import { Admin } from './pages/Admin'  // 대부분 사용자에게 불필요
+```
+
+**✅ 올바른 예시 (동적 import):**
+
+```typescript
+// JS/TS - 라우트별 코드 분할
+const Dashboard = lazy(() => import('./pages/Dashboard'))
+const Settings = lazy(() => import('./pages/Settings'))
+const Admin = lazy(() => import('./pages/Admin'))
+```
+
+```python
+# Python - 무거운 모듈 지연 로딩
+def analyze():
+    import pandas as pd  # 필요 시점에만 로드 (import 시간 ~200ms)
+    return pd.read_csv("data.csv")
+```
+
+```go
+// Go - 플러그인 시스템으로 런타임 로딩
+p, _ := plugin.Open("analytics.so")
+analyze, _ := p.Lookup("Analyze")
+```
+
+**프레임워크별 패턴:**
+
+| 프레임워크 | 코드 분할 방법 |
+|-----------|-------------|
+| React | `React.lazy()` + `Suspense` |
+| Vue | `defineAsyncComponent()` |
+| Svelte | `import()` in routes |
+| Next.js | `next/dynamic` |
+| TanStack Router | `.lazy.tsx` 파일 컨벤션 |
+| Angular | `loadChildren` (lazy routes) |
+
+**적용 기준:** 50KB+ 모듈, 조건부 표시 UI, 관리자 전용 기능.

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` |
+
+**주의:** 비슷해 보이지만 다른 의도의 코드는 추출하지 않음. 추상화 비용 > 중복 비용이면 중복 허용.