@kood/claude-code 0.1.0

package/templates/hono/docs/library/zod/index.md

@@ -0,0 +1,413 @@
+# Zod v4 - Schema Validation
+
+> TypeScript-first 스키마 선언 및 검증 라이브러리
+
+---
+
+## ⚠️ 버전 주의
+
+이 문서는 **Zod v4** 기준입니다. v3과 API가 다릅니다.
+
+```typescript
+// ✅ v4 문법
+z.email()
+z.url()
+z.uuid()
+
+// ❌ v3 문법 (사용 금지)
+z.string().email()
+z.string().url()
+z.string().uuid()
+```
+
+---
+
+## 설치
+
+```bash
+npm install zod
+```
+
+---
+
+## 기본 타입
+
+### Primitives
+
+```typescript
+import { z } from 'zod'
+
+// 문자열
+const stringSchema = z.string()
+
+// 숫자
+const numberSchema = z.number()
+
+// 불리언
+const booleanSchema = z.boolean()
+
+// BigInt
+const bigintSchema = z.bigint()
+
+// Date
+const dateSchema = z.date()
+
+// Undefined / Null
+const undefinedSchema = z.undefined()
+const nullSchema = z.null()
+```
+
+### 문자열 검증 (v4)
+
+```typescript
+// ✅ v4 전용 메서드
+z.email()                    // 이메일
+z.url()                      // URL
+z.uuid()                     // UUID
+z.cuid()                     // CUID
+z.ulid()                     // ULID
+z.ip()                       // IP 주소
+
+// 문자열 + 체이닝
+z.string().min(1)            // 최소 길이
+z.string().max(100)          // 최대 길이
+z.string().length(10)        // 정확한 길이
+z.string().trim()            // 앞뒤 공백 제거
+z.string().toLowerCase()     // 소문자 변환
+z.string().toUpperCase()     // 대문자 변환
+z.string().startsWith('a')   // 접두사
+z.string().endsWith('z')     // 접미사
+z.string().includes('test')  // 포함
+z.string().regex(/^[a-z]+$/) // 정규식
+```
+
+### 숫자 검증
+
+```typescript
+z.number().int()             // 정수
+z.number().positive()        // 양수
+z.number().negative()        // 음수
+z.number().nonnegative()     // 0 이상
+z.number().nonpositive()     // 0 이하
+z.number().min(1)            // 최소값
+z.number().max(100)          // 최대값
+z.number().multipleOf(5)     // 배수
+z.number().finite()          // 유한수
+z.number().safe()            // 안전한 정수 범위
+```
+
+---
+
+## 객체
+
+### 기본 객체
+
+```typescript
+const userSchema = z.object({
+  id: z.string(),
+  email: z.email(),
+  name: z.string().min(1).trim(),
+  age: z.number().int().positive(),
+})
+
+type User = z.infer<typeof userSchema>
+// { id: string; email: string; name: string; age: number }
+```
+
+### Optional / Nullable
+
+```typescript
+const schema = z.object({
+  required: z.string(),
+  optional: z.string().optional(),     // string | undefined
+  nullable: z.string().nullable(),     // string | null
+  nullish: z.string().nullish(),       // string | null | undefined
+})
+```
+
+### 기본값
+
+```typescript
+const schema = z.object({
+  name: z.string().default('Anonymous'),
+  role: z.enum(['user', 'admin']).default('user'),
+  active: z.boolean().default(true),
+})
+```
+
+### Partial / Required
+
+```typescript
+const userSchema = z.object({
+  name: z.string(),
+  email: z.email(),
+})
+
+// 모든 필드 optional
+const partialSchema = userSchema.partial()
+// { name?: string; email?: string }
+
+// 모든 필드 required
+const requiredSchema = partialSchema.required()
+// { name: string; email: string }
+
+// 특정 필드만 partial
+const mixedSchema = userSchema.partial({ email: true })
+// { name: string; email?: string }
+```
+
+### Pick / Omit
+
+```typescript
+const userSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  email: z.email(),
+  password: z.string(),
+})
+
+// 특정 필드만 선택
+const publicSchema = userSchema.pick({ id: true, name: true })
+// { id: string; name: string }
+
+// 특정 필드 제외
+const createSchema = userSchema.omit({ id: true })
+// { name: string; email: string; password: string }
+```
+
+### Extend / Merge
+
+```typescript
+const baseSchema = z.object({
+  id: z.string(),
+  createdAt: z.date(),
+})
+
+// 확장
+const userSchema = baseSchema.extend({
+  name: z.string(),
+  email: z.email(),
+})
+
+// 병합
+const anotherSchema = z.object({
+  updatedAt: z.date(),
+})
+const mergedSchema = baseSchema.merge(anotherSchema)
+```
+
+---
+
+## 배열
+
+```typescript
+// 기본 배열
+z.array(z.string())
+
+// 길이 제한
+z.array(z.string()).min(1)
+z.array(z.string()).max(10)
+z.array(z.string()).length(5)
+z.array(z.string()).nonempty()
+
+// 중복 제거 (unique는 없음, transform 사용)
+z.array(z.string()).transform((arr) => [...new Set(arr)])
+```
+
+---
+
+## Enum / Union
+
+### Enum
+
+```typescript
+// Zod enum
+const statusSchema = z.enum(['pending', 'active', 'completed'])
+type Status = z.infer<typeof statusSchema>
+// 'pending' | 'active' | 'completed'
+
+// TypeScript enum 사용
+enum Role {
+  User = 'user',
+  Admin = 'admin',
+}
+const roleSchema = z.nativeEnum(Role)
+```
+
+### Union
+
+```typescript
+// 기본 union
+const stringOrNumber = z.union([z.string(), z.number()])
+
+// Discriminated union
+const responseSchema = z.discriminatedUnion('type', [
+  z.object({ type: z.literal('success'), data: z.unknown() }),
+  z.object({ type: z.literal('error'), message: z.string() }),
+])
+```
+
+---
+
+## Coerce (타입 변환)
+
+```typescript
+// Query parameter 등에서 유용
+z.coerce.string()   // any → string
+z.coerce.number()   // string → number
+z.coerce.boolean()  // 'true'/'false' → boolean
+z.coerce.date()     // string → Date
+z.coerce.bigint()   // string → bigint
+```
+
+---
+
+## Transform
+
+```typescript
+// 값 변환
+const schema = z.string().transform((val) => val.toUpperCase())
+
+// 타입 변환
+const numberToString = z.number().transform((n) => String(n))
+
+// 복합 변환
+const userSchema = z.object({
+  email: z.email().transform((e) => e.toLowerCase()),
+  name: z.string().transform((n) => n.trim()),
+  tags: z.string().transform((s) => s.split(',').map((t) => t.trim())),
+})
+```
+
+---
+
+## Refine (커스텀 검증)
+
+### 단일 필드
+
+```typescript
+const passwordSchema = z.string().refine(
+  (password) => password.length >= 8 && /[A-Z]/.test(password),
+  { message: '8자 이상, 대문자 포함 필요' }
+)
+```
+
+### 객체 전체
+
+```typescript
+const schema = z.object({
+  password: z.string().min(8),
+  confirmPassword: z.string(),
+}).refine(
+  (data) => data.password === data.confirmPassword,
+  {
+    message: '비밀번호가 일치하지 않습니다',
+    path: ['confirmPassword'], // 에러 위치 지정
+  }
+)
+```
+
+### SuperRefine (고급)
+
+```typescript
+const schema = z.string().superRefine((val, ctx) => {
+  if (val.length < 8) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.too_small,
+      minimum: 8,
+      type: 'string',
+      inclusive: true,
+      message: '8자 이상 입력하세요',
+    })
+  }
+  if (!/[A-Z]/.test(val)) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: '대문자를 포함하세요',
+    })
+  }
+})
+```
+
+---
+
+## 에러 처리
+
+### safeParse
+
+```typescript
+const schema = z.object({
+  email: z.email(),
+  age: z.number().min(0),
+})
+
+const result = schema.safeParse(input)
+
+if (result.success) {
+  console.log(result.data) // 검증된 데이터
+} else {
+  console.log(result.error.flatten())
+  // {
+  //   formErrors: [],
+  //   fieldErrors: {
+  //     email: ['Invalid email'],
+  //     age: ['Number must be greater than or equal to 0']
+  //   }
+  // }
+}
+```
+
+### 커스텀 에러 메시지
+
+```typescript
+const schema = z.object({
+  email: z.email({ message: '올바른 이메일을 입력하세요' }),
+  name: z.string().min(1, { message: '이름을 입력하세요' }),
+  age: z.number()
+    .min(0, { message: '나이는 0 이상이어야 합니다' })
+    .max(150, { message: '나이는 150 이하여야 합니다' }),
+})
+```
+
+---
+
+## Hono와 함께 사용
+
+```typescript
+import { Hono } from 'hono'
+import { zValidator } from '@hono/zod-validator'
+import { z } from 'zod'
+
+const app = new Hono()
+
+// ✅ v4 문법 사용
+const createUserSchema = z.object({
+  email: z.email(),
+  name: z.string().min(1).trim(),
+  website: z.url().optional(),
+})
+
+app.post(
+  '/users',
+  zValidator('json', createUserSchema, (result, c) => {
+    if (!result.success) {
+      return c.json(
+        { errors: result.error.flatten().fieldErrors },
+        400
+      )
+    }
+  }),
+  (c) => {
+    const data = c.req.valid('json')
+    return c.json({ user: data }, 201)
+  }
+)
+```
+
+---
+
+## 관련 문서
+
+- [Hono 검증](../hono/validation.md)
+- [복잡한 타입](./complex-types.md)
+- [Transform](./transforms.md)

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

@@ -0,0 +1,106 @@
+# 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)

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

@@ -0,0 +1,94 @@
+# MCP 도구 가이드
+
+> Claude Code에서 사용하는 MCP (Model Context Protocol) 도구
+
+---
+
+## 📋 MCP 도구 개요
+
+| 도구 | 용도 | 사용 시점 |
+|------|------|----------|
+| **sgrep** | 코드 검색 | 코드베이스 검색 시 (grep/rg 대신) |
+| **Sequential Thinking** | 복잡한 분석 | 디버깅, 아키텍처 분석 |
+| **Context7** | 라이브러리 문서 | 공식 문서 참조 필요 시 |
+
+---
+
+## sgrep - 코드 검색
+
+> ⚠️ **필수**: 코드베이스 검색 시 grep/rg 대신 sgrep 사용
+
+### 사용 시점
+- 코드베이스에서 패턴 검색
+- 함수/클래스 사용처 찾기
+- 특정 패턴의 코드 찾기
+
+### 장점
+- AST 기반 시맨틱 검색
+- 언어별 최적화된 패턴 매칭
+- 정확한 코드 구조 인식
+
+---
+
+## Sequential Thinking - 분석 도구
+
+> 복잡한 문제를 단계별로 분석
+
+### 사용 시점
+- 복잡한 버그 디버깅
+- 아키텍처 분석/설계
+- 성능 병목 분석
+- 리팩토링 계획 수립
+
+### 특징
+- 단계별 사고 과정 기록
+- 가설 설정 및 검증
+- 체계적인 문제 해결
+
+---
+
+## Context7 - 라이브러리 문서
+
+> 공식 라이브러리 문서 조회
+
+### 사용 시점
+- 라이브러리 API 확인
+- 공식 문서 패턴 참조
+- 최신 버전 사용법 확인
+
+### 지원 라이브러리
+- Hono
+- Zod
+- Prisma
+- 기타 주요 라이브러리
+
+### 사용 예시
+```
+Context7로 Hono middleware 문서 조회
+Context7로 Zod v4 validation 문서 조회
+Context7로 Prisma transaction 문서 조회
+```
+
+---
+
+## MCP 도구 선택 가이드
+
+```
+코드 검색이 필요한가?
+├─ Yes → sgrep 사용
+└─ No
+   ├─ 복잡한 분석이 필요한가?
+   │  ├─ Yes → Sequential Thinking 사용
+   │  └─ No
+   │     └─ 라이브러리 문서가 필요한가?
+   │        ├─ Yes → Context7 사용
+   │        └─ No → 일반 도구 사용
+```
+
+---
+
+## 관련 문서
+
+- [sgrep 상세](./sgrep.md)
+- [Sequential Thinking 상세](./sequential-thinking.md)
+- [Context7 상세](./context7.md)

package/templates/hono/docs/mcp/sequential-thinking.md

@@ -0,0 +1,101 @@
+# Sequential Thinking
+
+> 복잡한 문제를 단계별로 분석하는 사고 도구
+
+---
+
+## 개요
+
+Sequential Thinking은 복잡한 문제를 체계적으로 분석하고 해결하기 위한 MCP 도구입니다.
+
+---
+
+## 사용 시점
+
+### ✅ 사용 권장
+- **복잡한 버그 디버깅**: 원인 파악이 어려운 버그
+- **아키텍처 분석/설계**: 시스템 구조 이해 및 설계
+- **성능 병목 분석**: 성능 문제 원인 파악
+- **리팩토링 계획**: 대규모 코드 변경 계획
+- **보안 취약점 분석**: 보안 이슈 탐지 및 해결
+
+### ❌ 사용 불필요
+- 단순한 코드 작성
+- 명확한 버그 수정
+- 간단한 질문 응답
+
+---
+
+## 분석 프로세스
+
+```
+1. 문제 정의
+   └─ 무엇을 해결해야 하는가?
+
+2. 정보 수집
+   └─ 관련 코드, 로그, 에러 메시지
+
+3. 가설 설정
+   └─ 가능한 원인들 나열
+
+4. 가설 검증
+   └─ 각 가설을 코드/데이터로 검증
+
+5. 결론 도출
+   └─ 검증된 원인과 해결책
+
+6. 실행 계획
+   └─ 구체적인 수정 단계
+```
+
+---
+
+## 예시 상황
+
+### 복잡한 버그 디버깅
+```
+문제: "API 응답이 간헐적으로 느림"
+
+Sequential Thinking 활용:
+1. 느린 요청의 패턴 분석
+2. 가능한 원인 나열 (DB, 네트워크, 코드)
+3. 각 원인별 증거 수집
+4. 병목 지점 확인
+5. 해결책 제시
+```
+
+### 아키텍처 분석
+```
+문제: "마이크로서비스 분리 계획"
+
+Sequential Thinking 활용:
+1. 현재 모놀리스 구조 분석
+2. 도메인 경계 식별
+3. 의존성 그래프 작성
+4. 분리 우선순위 결정
+5. 마이그레이션 계획 수립
+```
+
+---
+
+## 장점
+
+### 1. 체계적 접근
+- 단계별 사고 과정 기록
+- 놓치는 부분 최소화
+
+### 2. 가설 기반 분석
+- 추측이 아닌 검증 기반
+- 명확한 근거 제시
+
+### 3. 재사용 가능
+- 분석 과정 문서화
+- 유사 문제에 적용 가능
+
+---
+
+## 관련 문서
+
+- [MCP 개요](./index.md)
+- [sgrep](./sgrep.md)
+- [Context7](./context7.md)