@kood/claude-code 0.1.5 → 0.1.7

package/templates/tanstack-start/docs/library/zod/transforms.md

@@ -1,148 +1,56 @@
 # Zod - 변환
 
-> **상위 문서**: [Zod](./index.md)
-
 ## Transform
 
-입력값을 다른 형태로 변환합니다.
-
 ```typescript
 const stringToLength = z.string().transform((val) => val.length)
+stringToLength.parse('hello')  // => 5
 
-stringToLength.parse('string') // => 6
-
-type MySchemaIn = z.input<typeof stringToLength>   // string
-type MySchemaOut = z.output<typeof stringToLength> // number
-```
-
-### 체인으로 변환
-
-```typescript
-const emailToLower = z.string()
-  .email()
-  .transform((email) => email.toLowerCase())
-
-emailToLower.parse('User@Example.COM') // => "user@example.com"
-```
-
-## Pipe를 사용한 Transform
-
-```typescript
-const stringToLength = z.string().pipe(z.transform(val => val.length))
-
-stringToLength.parse('hello') // => 5
+type In = z.input<typeof stringToLength>   // string
+type Out = z.output<typeof stringToLength> // number
 ```
 
-### 검증 후 변환
+## Pipe (검증 후 변환)
 
 ```typescript
 const stringToNumber = z.string()
   .transform((val) => parseInt(val, 10))
   .pipe(z.number().min(0).max(100))
 
-stringToNumber.parse('50') // => 50
-stringToNumber.parse('150') // => throws
-```
-
-## Transform 내에서 검증
-
-```typescript
-const coercedInt = z.transform((val, ctx) => {
-  try {
-    const parsed = Number.parseInt(String(val))
-    return parsed
-  } catch (e) {
-    ctx.issues.push({
-      code: 'custom',
-      message: 'Not a number',
-      input: val,
-    })
-    return z.NEVER // 타입에 영향 없이 에러 반환
-  }
-})
+stringToNumber.parse('50')  // => 50
+stringToNumber.parse('150') // throws
 ```
 
 ## Coerce (강제 변환)
 
-입력값을 자동으로 해당 타입으로 변환합니다.
-
-```typescript
-z.coerce.string()   // 모든 값을 문자열로
-z.coerce.number()   // 모든 값을 숫자로
-z.coerce.boolean()  // 모든 값을 불리언으로
-z.coerce.date()     // 모든 값을 날짜로
-z.coerce.bigint()   // 모든 값을 BigInt로
-```
-
-### v4 Coerce 입력 타입 변경
-
 ```typescript
-const schema = z.coerce.string()
-type schemaInput = z.input<typeof schema>
-// v3: string
-// v4: unknown  // ⚠️ 주의: 입력 타입이 unknown으로 변경됨
-```
+z.coerce.string()   // 모든 값 → 문자열
+z.coerce.number()   // 모든 값 → 숫자
+z.coerce.boolean()  // 모든 값 → 불리언
+z.coerce.date()     // 모든 값 → 날짜
+z.coerce.bigint()   // 모든 값 → BigInt
 
-### Coerce 예시
+z.coerce.number().parse("42")  // => 42
+z.coerce.date().parse("2021-01-01")  // => Date
 
-```typescript
-// string coercion
-z.coerce.string().parse(123)     // => "123"
-z.coerce.string().parse(true)    // => "true"
-z.coerce.string().parse(null)    // => "null"
-
-// number coercion
-z.coerce.number().parse("42")    // => 42
-z.coerce.number().parse(true)    // => 1
-z.coerce.number().parse(false)   // => 0
-
-// boolean coercion
-z.coerce.boolean().parse("true") // => true
-z.coerce.boolean().parse("")     // => false
-z.coerce.boolean().parse(1)      // => true
-
-// date coercion
-z.coerce.date().parse("2021-01-01") // => Date
-z.coerce.date().parse(1609459200000) // => Date
+// ⚠️ v4: 입력 타입이 unknown으로 변경됨
+type In = z.input<typeof z.coerce.string()>  // unknown
 ```
 
 ### 환경변수 불리언 (v4 권장)
 
-`z.coerce.boolean()` 대신 더 정교한 `z.stringbool()` 사용:
-
 ```typescript
-const strbool = z.stringbool()
-
-strbool.parse("true")     // => true
-strbool.parse("yes")      // => true
-strbool.parse("1")        // => true
-strbool.parse("false")    // => false
-strbool.parse("no")       // => false
-strbool.parse("0")        // => false
+z.stringbool()  // "true"/"yes"/"1" → true
+                // "false"/"no"/"0" → false
 ```
 
 ## Preprocess
 
-검증 전에 데이터를 전처리합니다.
-
-```typescript
-const castToString = z.preprocess((val) => String(val), z.string())
-
-castToString.parse(123) // => "123"
-castToString.parse(null) // => "null"
-```
-
-### Preprocess vs Coerce
-
 ```typescript
-// preprocess - 커스텀 로직 가능
-const trimmedString = z.preprocess(
+const trimmed = z.preprocess(
   (val) => typeof val === 'string' ? val.trim() : val,
   z.string()
 )
-
-// coerce - 내장 변환만
-const coercedString = z.coerce.string()
 ```
 
 ## 입력/출력 타입 분리
@@ -152,23 +60,6 @@ const Schema = z.object({
   createdAt: z.string().transform((str) => new Date(str)),
 })
 
-type SchemaInput = z.input<typeof Schema>
-// { createdAt: string }
-
-type SchemaOutput = z.output<typeof Schema>
-// { createdAt: Date }
-```
-
-## 조건부 변환
-
-```typescript
-const conditionalTransform = z.string().transform((val) => {
-  if (val === 'null') return null
-  if (val === 'undefined') return undefined
-  return val
-})
-
-conditionalTransform.parse('hello')     // => "hello"
-conditionalTransform.parse('null')      // => null
-conditionalTransform.parse('undefined') // => undefined
+type SchemaInput = z.input<typeof Schema>   // { createdAt: string }
+type SchemaOutput = z.output<typeof Schema> // { createdAt: Date }
 ```

package/templates/tanstack-start/docs/library/zod/validation.md

@@ -1,208 +1,92 @@
 # Zod - 검증
 
-> **상위 문서**: [Zod](./index.md)
-
-## Refinement (커스텀 검증)
+## Refinement
 
 ```typescript
-// v4 - error 파라미터 사용 (message는 deprecated)
+// v4: message → error
 const PasswordSchema = z.string()
   .min(8)
-  .refine((val) => /[A-Z]/.test(val), {
-    error: '대문자가 포함되어야 합니다',  // v4: message → error
-  })
-  .refine((val) => /[0-9]/.test(val), {
-    error: '숫자가 포함되어야 합니다',
-  })
-```
+  .refine((val) => /[A-Z]/.test(val), { error: '대문자 필수' })
+  .refine((val) => /[0-9]/.test(val), { error: '숫자 필수' })
 
-### v4 Refinement 체이닝 개선
+// v4: refinement 후 체이닝 가능
+z.string().refine(val => val.includes("@")).min(5)  // ✅
 
-```typescript
-// v3 - ZodEffects로 래핑되어 .min() 호출 불가
-z.string()
-  .refine(val => val.includes("@"))
-  .min(5) // ❌ 에러
-
-// v4 - 스키마 내부에 저장되어 체이닝 가능
-z.string()
-  .refine(val => val.includes("@"))
-  .min(5) // ✅ 정상 작동
-```
-
-### Async Refinement
-
-```typescript
+// Async
 const schema = z.string().refine(async (val) => val.length <= 8)
-
-await schema.parseAsync('hello') // => "hello"
-```
-
-### 이메일 중복 검사 예시
-
-```typescript
-const EmailSchema = z.email()  // v4 새 API
-  .refine(async (email) => {
-    const exists = await checkEmailExists(email)
-    return !exists
-  }, {
-    error: '이미 사용 중인 이메일입니다',  // v4: message → error
-  })
+await schema.parseAsync('hello')
 ```
 
-## Superrefine (고급 검증)
-
-여러 이슈를 추가하거나 경로를 지정할 수 있습니다.
-
-> **v4 변경**: `ctx.path`는 더 이상 사용할 수 없습니다 (성능 향상을 위해 제거됨)
+## Superrefine (고급)
 
 ```typescript
-const Schema = z.object({
+z.object({
   password: z.string(),
   confirmPassword: z.string(),
 }).superRefine((data, ctx) => {
   if (data.password !== data.confirmPassword) {
     ctx.addIssue({
       code: z.ZodIssueCode.custom,
-      message: '비밀번호가 일치하지 않습니다',
+      message: '비밀번호 불일치',
       path: ['confirmPassword'],
     })
   }
-  // ctx.path // ❌ v4에서 더 이상 사용 불가
 })
+// ⚠️ v4: ctx.path 사용 불가
 ```
 
-### 복잡한 검증 로직
+## 커스텀 스키마
 
 ```typescript
-const UserSchema = z.object({
-  username: z.string(),
-  email: z.string().email(),
-  age: z.number(),
-}).superRefine((data, ctx) => {
-  // 여러 조건 검증
-  if (data.age < 13 && data.email.includes('work')) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      message: '13세 미만은 업무용 이메일을 사용할 수 없습니다',
-      path: ['email'],
-    })
-  }
+const px = z.custom<`${number}px`>((val) =>
+  typeof val === 'string' && /^\d+px$/.test(val)
+)
 
-  if (data.username.toLowerCase() === 'admin' && data.age < 18) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      message: 'admin 사용자명은 18세 이상만 사용 가능합니다',
-      path: ['username'],
-    })
-  }
-})
+px.parse('42px')  // ✅
+px.parse('42vw')  // throws
 ```
 
-## 커스텀 스키마
+## 에러 처리
 
 ```typescript
-const px = z.custom<`${number}px`>((val) => {
-  return typeof val === 'string' ? /^\d+px$/.test(val) : false
-})
+const result = schema.safeParse(data)
 
-type Px = z.infer<typeof px> // `${number}px`
+if (!result.success) {
+  result.error.errors.forEach((err) => {
+    console.log(err.path, err.message, err.code)
+  })
 
-px.parse('42px')  // '42px'
-px.parse('42vw')  // throws
+  // 평면화
+  const flat = result.error.flatten()
+  // { fieldErrors: { email: ['Invalid email'] } }
+}
 ```
 
-## TanStack Start와 함께 사용
-
-### Server Function 입력 검증
+## TanStack Start 연동
 
 ```typescript
-import { createServerFn } from '@tanstack/react-start'
-import { zodValidator } from '@tanstack/react-start/validators'
-import { z } from 'zod'
-
-const createUserSchema = z.object({
-  email: z.email(),  // v4 새 API
-  name: z.string().min(1).max(100).trim(),
-  bio: z.string().max(500).optional(),
-})
-
+// Server Function
 export const createUser = createServerFn({ method: 'POST' })
   .inputValidator(zodValidator(createUserSchema))
-  .handler(async ({ data }) => {
-    // data는 타입 안전함
-    return prisma.user.create({ data })
-  })
-```
-
-### 환경 변수 검증
+  .handler(async ({ data }) => prisma.user.create({ data }))
 
-```typescript
-const envSchema = z.object({
+// 환경 변수
+const env = z.object({
   NODE_ENV: z.enum(['development', 'production', 'test']),
   DATABASE_URL: z.string().url(),
   API_SECRET: z.string().min(32),
-})
-
-export const env = envSchema.parse(process.env)
-```
-
-### Middleware에서 사용
-
-```typescript
-import { createMiddleware } from '@tanstack/react-start'
-import { zodValidator } from '@tanstack/react-start/validators'
-import { z } from 'zod'
-
-const mySchema = z.object({
-  workspaceId: z.string(),
-})
+}).parse(process.env)
 
+// Middleware
 const workspaceMiddleware = createMiddleware({ type: 'function' })
-  .inputValidator(zodValidator(mySchema))
-  .server(({ next, data }) => {
-    console.log('Workspace ID:', data.workspaceId)
-    return next()
-  })
-```
-
-## 에러 처리
-
-```typescript
-const result = UserSchema.safeParse(data)
-
-if (!result.success) {
-  // ZodError 객체
-  const errors = result.error.errors
-
-  errors.forEach((err) => {
-    console.log('Path:', err.path)
-    console.log('Message:', err.message)
-    console.log('Code:', err.code)
-  })
-
-  // 평면화된 에러
-  const flatErrors = result.error.flatten()
-  console.log(flatErrors.fieldErrors)
-  // { email: ['Invalid email'], name: ['Required'] }
-}
+  .inputValidator(zodValidator(z.object({ workspaceId: z.string() })))
+  .server(({ next, data }) => next())
 ```
 
-## Zod Mini (경량 버전)
-
-v4에서 새롭게 추가된 경량 API:
+## Zod Mini (v4 경량)
 
 ```typescript
 import * as z from "zod/mini"
 
-// regular Zod
-z.string().min(5).max(10).trim()
-
-// Zod Mini - check 메서드로 통합
-z.string().check(
-  z.minLength(5),
-  z.maxLength(10),
-  z.toLowerCase(),
-  z.trim(),
-)
+z.string().check(z.minLength(5), z.maxLength(10), z.trim())
 ```

package/templates/hono/docs/commands/git.md

@@ -1,145 +0,0 @@
-현재 git 상태를 확인하고, 아래 규칙에 따라 작업을 진행해주세요.
-
-**추가 지시사항**: $ARGUMENTS
-
----
-
-## 실행 절차
-
-### 추가 지시사항이 없는 경우 (기본 동작)
-1. `git status`로 현재 상태 확인
-2. `git diff`로 변경 내용 분석
-3. 스테이징 안 된 변경사항 → `git add`
-4. 커밋 안 된 변경사항 → 논리적 단위로 분리하여 `git commit`
-5. 최종 `git status`로 완료 확인
-
-### 추가 지시사항이 있는 경우
-- 사용자의 지시사항을 우선적으로 따름
-- 예: `/git push` → push 진행, `/git 특정파일만 커밋` → 해당 파일만 처리
-
----
-
-## ⛔ NEVER (절대 금지)
-
-```
-❌ 커밋에 "Generated with Claude Code" 포함
-❌ 커밋에 "🤖" 또는 AI 관련 이모지 포함
-❌ 커밋에 "Co-Authored-By:" 헤더 포함
-❌ 커밋에 AI/봇이 작성했다는 어떤 표시도 포함
-❌ 커밋 메시지 여러 줄 작성
-❌ 커밋 메시지에 이모지 사용
-❌ 커밋 메시지에 마침표(.) 사용
-❌ 여러 작업을 하나의 커밋으로 퉁치기
-```
-
----
-
-## ✅ ALWAYS (필수)
-
-### 커밋 형식
-
-```
-<prefix>: <설명>
-```
-
-**한 줄로 간결하게** 작성합니다. 본문이나 푸터는 작성하지 않습니다.
-
-### ⭐ 커밋 분리 원칙
-
-**하나의 커밋 = 하나의 논리적 변경 단위**
-
-```bash
-# ❌ 잘못된 방식: 모든 작업을 하나로 퉁침
-git add .
-git commit -m "feat: 여러 기능 추가"
-
-# ✅ 올바른 방식: 논리적 단위로 분리
-git add src/auth/
-git commit -m "feat: 사용자 인증 기능 추가"
-
-git add src/users/
-git commit -m "feat: 사용자 관리 기능 추가"
-
-git add docs/
-git commit -m "docs: API 문서 업데이트"
-```
-
----
-
-## 🏷 Prefix 목록
-
-| Prefix | 용도 | 예시 |
-|--------|------|------|
-| `feat` | 새로운 기능 | `feat: 사용자 인증 기능 추가` |
-| `fix` | 버그 수정 | `fix: 토큰 검증 오류 수정` |
-| `refactor` | 리팩토링 | `refactor: 인증 로직 분리` |
-| `style` | 코드 스타일 | `style: prettier 적용` |
-| `docs` | 문서 수정 | `docs: API 문서 업데이트` |
-| `test` | 테스트 | `test: 인증 테스트 추가` |
-| `chore` | 빌드/설정 | `chore: 의존성 업데이트` |
-| `perf` | 성능 개선 | `perf: 쿼리 최적화` |
-| `ci` | CI/CD | `ci: GitHub Actions 추가` |
-
----
-
-## ✅ 올바른 예시
-
-```bash
-feat: 사용자 로그인 기능 추가
-fix: 세션 만료 오류 수정
-refactor: 서비스 클래스 구조 개선
-docs: README 설치 가이드 추가
-chore: 의존성 버전 업그레이드
-```
-
----
-
-## ❌ 잘못된 예시
-
-```bash
-# prefix 없음
-사용자 인증 기능 추가함
-
-# 마침표 불필요
-feat: 사용자 인증 추가.
-
-# 대문자 사용
-FEAT: 사용자 인증 추가
-
-# scope 불필요
-feat(auth): 인증 추가
-
-# AI 작성 표시 (절대 금지!)
-feat: 로그인 기능 추가
-
-🤖 Generated with Claude Code
-
-# Co-Author 표시 (절대 금지!)
-feat: 로그인 기능 추가
-
-Co-Authored-By: Claude <noreply@anthropic.com>
-
-# 여러 줄 본문 (금지)
-feat: 로그인 기능 추가
-
-- 이메일 인증 추가
-- 세션 관리 구현
-
-# 여러 작업을 하나로 퉁침 (금지)
-feat: 로그인, 회원가입, 프로필 기능 추가
-```
-
----
-
-## 📦 커밋 분리 가이드
-
-### 언제 커밋을 분리해야 하나요?
-
-| 상황 | 커밋 분리 |
-|------|----------|
-| 서로 다른 기능 구현 | ✅ 분리 |
-| 버그 수정 + 새 기능 | ✅ 분리 |
-| 코드 변경 + 문서 변경 | ✅ 분리 |
-| 리팩토링 + 기능 추가 | ✅ 분리 |
-| 동일 기능의 관련 파일들 | 🔄 묶어도 됨 |
-| 동일 기능의 타입 + 구현 | 🔄 묶어도 됨 |

package/templates/hono/docs/mcp/context7.md

@@ -1,106 +0,0 @@
-# Context7
-
-> 라이브러리 공식 문서 조회 도구
-
----
-
-## 개요
-
-Context7은 주요 라이브러리의 공식 문서를 조회하여 정확한 API 정보와 사용 패턴을 제공합니다.
-
----
-
-## 사용 시점
-
-### ✅ 사용 권장
-- **API 확인**: 라이브러리 함수/메서드 사용법
-- **공식 패턴**: 권장되는 코드 패턴
-- **버전별 차이**: 특정 버전의 API 확인
-- **최신 정보**: 최신 릴리즈 기능 확인
-
-### ❌ 사용 불필요
-- 이미 알고 있는 기본 API
-- 프로젝트 내부 코드 관련 질문
-- 일반적인 프로그래밍 개념
-
----
-
-## 지원 라이브러리
-
-### 주요 지원
-- **Hono**: 라우팅, 미들웨어, RPC
-- **Zod**: 스키마 정의, 검증
-- **Prisma**: ORM, 쿼리, 마이그레이션
-- **TypeScript**: 타입 시스템
-
-### 기타 지원
-- React, Vue, Angular
-- Express, Fastify
-- 기타 주요 npm 패키지
-
----
-
-## 사용 예시
-
-### Hono 문서 조회
-```
-"Hono의 zValidator 사용법 조회"
-"Hono middleware 작성 패턴 조회"
-"Hono RPC client 설정 방법 조회"
-```
-
-### Zod 문서 조회
-```
-"Zod v4의 z.email() 사용법 조회"
-"Zod transform 패턴 조회"
-"Zod discriminatedUnion 사용법 조회"
-```
-
-### Prisma 문서 조회
-```
-"Prisma v7 generator 설정 조회"
-"Prisma transaction 패턴 조회"
-"Prisma relation 쿼리 방법 조회"
-```
-
----
-
-## 장점
-
-### 1. 정확한 정보
-- 공식 문서 기반
-- 검증된 코드 예시
-
-### 2. 최신 정보
-- 최신 버전 반영
-- 업데이트된 API
-
-### 3. 버전 특정
-- 특정 버전 문서 조회
-- 버전 간 차이 확인
-
----
-
-## 워크플로우
-
-```
-1. 필요한 정보 파악
-   └─ 어떤 라이브러리의 어떤 기능?
-
-2. Context7 조회
-   └─ 해당 라이브러리 문서 검색
-
-3. 정보 확인
-   └─ API 시그니처, 사용 예시
-
-4. 코드 적용
-   └─ 프로젝트에 맞게 적용
-```
-
----
-
-## 관련 문서
-
-- [MCP 개요](./index.md)
-- [sgrep](./sgrep.md)
-- [Sequential Thinking](./sequential-thinking.md)