@kood/claude-code 0.1.6 → 0.1.7

package/templates/tanstack-start/docs/library/tanstack-start/setup.md

@@ -1,15 +1,13 @@
 # TanStack Start - 설치 및 설정
 
-> **상위 문서**: [TanStack Start](./index.md)
-
-## 패키지 설치
+## 설치
 
 ```bash
 yarn add @tanstack/react-start @tanstack/react-router vinxi
 yarn add -D vite @vitejs/plugin-react vite-tsconfig-paths
 ```
 
-## Vite 설정
+## 설정
 
 ```typescript
 // vite.config.ts
@@ -19,19 +17,11 @@ import { tanstackStart } from '@tanstack/react-start/plugin/vite'
 import viteReact from '@vitejs/plugin-react'
 
 export default defineConfig({
-  server: {
-    port: 3000,
-  },
-  plugins: [
-    tsConfigPaths(),
-    tanstackStart(),
-    viteReact(),
-  ],
+  server: { port: 3000 },
+  plugins: [tsConfigPaths(), tanstackStart(), viteReact()],
 })
 ```
 
-## TypeScript 설정
-
 ```json
 // tsconfig.json
 {
@@ -40,35 +30,12 @@ export default defineConfig({
     "module": "ESNext",
     "moduleResolution": "bundler",
     "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
     "jsx": "react-jsx",
-    "baseUrl": ".",
-    "paths": {
-      "@/*": ["./src/*"]
-    }
-  },
-  "include": ["src/**/*"]
+    "paths": { "@/*": ["./src/*"] }
+  }
 }
 ```
 
-## 프로젝트 구조
-
-```
-project/
-├── src/
-│   ├── routes/
-│   │   ├── __root.tsx
-│   │   ├── index.tsx
-│   │   └── about.tsx
-│   ├── lib/
-│   │   └── server-functions.ts
-│   └── start.ts
-├── vite.config.ts
-├── tsconfig.json
-└── package.json
-```
-
 ## 환경 변수 검증
 
 ```typescript

package/templates/tanstack-start/docs/library/zod/basic-types.md

@@ -1,186 +1,74 @@
 # Zod - 기본 타입
 
-> **상위 문서**: [Zod](./index.md)
-
 ## 문자열
 
 ```typescript
 z.string()
-z.string().min(1)          // 최소 길이
-z.string().max(100)        // 최대 길이
-z.string().length(5)       // 정확한 길이
-z.string().regex(/^\d+$/)  // 정규식
-z.string().trim()          // 공백 제거
-z.string().toLowerCase()   // 소문자 변환
-z.string().toUpperCase()   // 대문자 변환
+z.string().min(1).max(100).length(5)
+z.string().regex(/^\d+$/)
+z.string().trim().toLowerCase().toUpperCase()
 ```
 
-### v4 새로운 최상위 문자열 포맷 API
+### v4 최상위 포맷 API
 
 ```typescript
-// 더 나은 tree-shaking을 위해 최상위 API 사용 권장
-z.email()           // 이메일 형식
-z.url()             // URL 형식
-z.uuid()            // UUID 형식
-z.base64()          // Base64 형식
-z.base64url()       // Base64 URL 형식
-z.nanoid()          // NanoID 형식
-z.cuid()            // CUID 형식
-z.cuid2()           // CUID2 형식
-z.ulid()            // ULID 형식
-z.emoji()           // 이모지 (단일 문자)
-z.ipv4()            // IPv4 주소
-z.ipv6()            // IPv6 주소
-z.cidrv4()          // IPv4 범위
-z.cidrv6()          // IPv6 범위
-
-// ISO 날짜/시간 형식
-z.iso.date()        // ISO 날짜 (2024-01-15)
-z.iso.time()        // ISO 시간 (14:30:00)
-z.iso.datetime()    // ISO 날짜시간
-z.iso.duration()    // ISO 기간 (P1D, PT1H)
+z.email()    z.url()      z.uuid()     z.base64()
+z.nanoid()   z.cuid()     z.cuid2()    z.ulid()
+z.ipv4()     z.ipv6()     z.cidrv4()   z.cidrv6()
+
+z.iso.date()      // 2024-01-15
+z.iso.time()      // 14:30:00
+z.iso.datetime()  // ISO 날짜시간
+z.iso.duration()  // P1D, PT1H
 ```
 
-### 템플릿 리터럴 타입 (v4 신규)
+### 템플릿 리터럴 (v4)
 
 ```typescript
-const hello = z.templateLiteral(["hello, ", z.string()])
-// `hello, ${string}`
-
-const cssUnits = z.enum(["px", "em", "rem", "%"])
-const css = z.templateLiteral([z.number(), cssUnits])
-// `${number}px` | `${number}em` | `${number}rem` | `${number}%`
-
-const email = z.templateLiteral([
-  z.string().min(1),
-  "@",
-  z.string().max(64),
-])
-// `${string}@${string}` (min/max refinements도 적용됨!)
+const css = z.templateLiteral([z.number(), z.enum(["px", "em", "rem"])])
+// `${number}px` | `${number}em` | `${number}rem`
 ```
 
 ## 숫자
 
 ```typescript
 z.number()
-z.number().min(0)          // 최솟값
-z.number().max(100)        // 최댓값
-z.number().int()           // 정수만
-z.number().positive()      // 양수만
-z.number().negative()      // 음수만
-z.number().nonnegative()   // 0 이상
-z.number().nonpositive()   // 0 이하
-z.number().finite()        // 유한 숫자
-z.number().safe()          // 안전한 정수 범위
+z.number().min(0).max(100).int()
+z.number().positive().negative().nonnegative().nonpositive()
+z.number().finite().safe()
 ```
 
 ## 불리언
 
 ```typescript
 z.boolean()
-```
-
-### 문자열 불리언 (v4 신규)
-
-환경변수 스타일 불리언 변환:
-
-```typescript
-const strbool = z.stringbool()
-
-strbool.parse("true")     // => true
-strbool.parse("1")        // => true
-strbool.parse("yes")      // => true
-strbool.parse("on")       // => true
-strbool.parse("enabled")  // => true
-
-strbool.parse("false")    // => false
-strbool.parse("0")        // => false
-strbool.parse("no")       // => false
-strbool.parse("off")      // => false
-strbool.parse("disabled") // => false
-
-// 커스텀 truthy/falsy 값
-z.stringbool({
-  truthy: ["yes", "true"],
-  falsy: ["no", "false"]
-})
-```
-
-## 날짜
-
-```typescript
-z.date()
-z.date().min(new Date('2020-01-01'))
-z.date().max(new Date('2030-12-31'))
-```
-
-## BigInt
-
-```typescript
-z.bigint()
-z.bigint().positive()
-z.bigint().negative()
-```
-
-## 리터럴
-
-```typescript
-z.literal('hello')       // 정확히 'hello'만
-z.literal(42)            // 정확히 42만
-z.literal(true)          // 정확히 true만
-```
-
-## Null, Undefined, Void
-
-```typescript
-z.null()       // null만 허용
-z.undefined()  // undefined만 허용
-z.void()       // undefined 허용 (반환 타입용)
-```
 
-## Any, Unknown, Never
-
-```typescript
-z.any()      // 모든 타입 허용
-z.unknown()  // unknown 타입
-z.never()    // 값 없음 (유니온에서 사용)
+// v4 문자열 불리언 (환경변수용)
+z.stringbool()  // "true"/"yes"/"1" → true, "false"/"no"/"0" → false
 ```
 
-> **v4 변경**: `z.any()`와 `z.unknown()`은 더 이상 객체에서 선택적 키로 추론되지 않습니다.
-> ```typescript
-> const mySchema = z.object({ a: z.any(), b: z.unknown() })
-> // v3: { a?: any; b?: unknown }
-> // v4: { a: any; b: unknown }
-> ```
-
-## Optional & Nullable
+## 날짜/BigInt/리터럴
 
 ```typescript
-z.string().optional()  // string | undefined
-z.string().nullable()  // string | null
-z.string().nullish()   // string | null | undefined
+z.date().min(new Date('2020-01-01')).max(new Date('2030-12-31'))
+z.bigint().positive().negative()
+z.literal('hello')  z.literal(42)  z.literal(true)
 ```
 
-## Default 값
+## 특수 타입
 
 ```typescript
-const Schema = z.object({
-  name: z.string().default('Anonymous'),
-  role: z.enum(['admin', 'user']).default('user'),
-})
-
-Schema.parse({}) // { name: 'Anonymous', role: 'user' }
+z.null()       z.undefined()    z.void()
+z.any()        z.unknown()      z.never()
 ```
 
-## 타입 추론
+## 수정자
 
 ```typescript
-const stringSchema = z.string()
-type StringType = z.infer<typeof stringSchema> // string
-
-const numberSchema = z.number().optional()
-type NumberType = z.infer<typeof numberSchema> // number | undefined
+z.string().optional()   // string | undefined
+z.string().nullable()   // string | null
+z.string().nullish()    // string | null | undefined
+z.string().default('Anonymous')
 
-const dateSchema = z.date().nullable()
-type DateType = z.infer<typeof dateSchema> // Date | null
+type T = z.infer<typeof schema>
 ```

package/templates/tanstack-start/docs/library/zod/complex-types.md

@@ -1,204 +1,80 @@
 # Zod - 복합 타입
 
-> **상위 문서**: [Zod](./index.md)
-
 ## 객체
 
 ```typescript
 const UserSchema = z.object({
   name: z.string(),
-  email: z.email(),  // v4 새 API
-  age: z.number().optional(),  // 선택적 필드
-})
-
-// 검증
-const result = UserSchema.parse({
-  name: 'john',
-  email: 'john@example.com',
-  age: 25,
-})
-
-// 안전한 검증
-const safeResult = UserSchema.safeParse(data)
-if (safeResult.success) {
-  console.log(safeResult.data)
-} else {
-  console.log(safeResult.error)
-}
-```
-
-### 객체 메서드
-
-```typescript
-// 부분 객체 (모든 필드가 optional)
-const PartialUser = UserSchema.partial()
-
-// 필수 객체 (모든 필드가 required)
-const RequiredUser = UserSchema.required()
-
-// 필드 선택
-const UserName = UserSchema.pick({ name: true })
-
-// 필드 제외
-const UserWithoutEmail = UserSchema.omit({ email: true })
-
-// 확장
-const ExtendedUser = UserSchema.extend({
-  role: z.enum(['admin', 'user']),
+  email: z.email(),
+  age: z.number().optional(),
 })
 
-// 병합
-const MergedSchema = UserSchema.merge(AnotherSchema)
-```
-
-### Strict/Loose 객체 (v4)
+// 메서드
+UserSchema.partial()              // 모든 필드 optional
+UserSchema.required()             // 모든 필드 required
+UserSchema.pick({ name: true })   // 특정 필드만
+UserSchema.omit({ email: true })  // 특정 필드 제외
+UserSchema.extend({ role: z.enum(['admin', 'user']) })
+UserSchema.merge(AnotherSchema)
 
-```typescript
-// v3
-z.object({ name: z.string() }).strict()     // 추가 키 에러
-z.object({ name: z.string() }).passthrough() // 추가 키 통과
-
-// v4 - 새로운 API
+// v4 Strict/Loose
 z.strictObject({ name: z.string() })  // 추가 키 에러
 z.looseObject({ name: z.string() })   // 추가 키 통과
 ```
 
-## 배열
+## 배열/튜플
 
 ```typescript
 z.array(z.string())
-z.array(z.number()).min(1)     // 최소 1개
-z.array(z.number()).max(10)    // 최대 10개
-z.array(z.number()).length(5)  // 정확히 5개
-z.array(z.number()).nonempty() // 비어있지 않음
-```
+z.array(z.number()).min(1).max(10).length(5).nonempty()
 
-## 튜플
-
-```typescript
-const tuple = z.tuple([
-  z.string(),  // 첫 번째 요소
-  z.number(),  // 두 번째 요소
-])
-
-type Tuple = z.infer<typeof tuple>
-// [string, number]
+z.tuple([z.string(), z.number()])  // [string, number]
 ```
 
 ## 유니온
 
 ```typescript
-const StringOrNumber = z.union([z.string(), z.number()])
-// 또는
-const StringOrNumber = z.string().or(z.number())
-
-type StringOrNumber = z.infer<typeof StringOrNumber>
-// string | number
-```
+z.union([z.string(), z.number()])
+z.string().or(z.number())
 
-## Discriminated Union
-
-```typescript
-const Shape = z.discriminatedUnion('type', [
+// Discriminated Union
+z.discriminatedUnion('type', [
   z.object({ type: z.literal('circle'), radius: z.number() }),
   z.object({ type: z.literal('rectangle'), width: z.number(), height: z.number() }),
 ])
-
-type Shape = z.infer<typeof Shape>
-// { type: 'circle'; radius: number } | { type: 'rectangle'; width: number; height: number }
-```
-
-### v4 향상된 Discriminated Union
-
-```typescript
-// 유니온 및 파이프 discriminator 지원
-const MyResult = z.discriminatedUnion("status", [
-  // 단순 리터럴
-  z.object({ status: z.literal("aaa"), data: z.string() }),
-  // 유니온 discriminator
-  z.object({ status: z.union([z.literal("bbb"), z.literal("ccc")]) }),
-  // 파이프 discriminator
-  z.object({ status: z.literal("fail").transform(val => val.toUpperCase()) }),
-])
-
-// 중첩 discriminated union
-const BaseError = z.object({ status: z.literal("failed"), message: z.string() })
-
-const MyResult2 = z.discriminatedUnion("status", [
-  z.object({ status: z.literal("success"), data: z.string() }),
-  z.discriminatedUnion("code", [
-    BaseError.extend({ code: z.literal(400) }),
-    BaseError.extend({ code: z.literal(401) }),
-    BaseError.extend({ code: z.literal(500) })
-  ])
-])
 ```
 
 ## Enum
 
 ```typescript
-// 문자열 enum
-const FishEnum = z.enum(['Salmon', 'Tuna', 'Trout'])
-
-FishEnum.parse('Salmon') // => "Salmon"
-FishEnum.parse('Swordfish') // => ❌ throws
-
-type Fish = z.infer<typeof FishEnum>
-// 'Salmon' | 'Tuna' | 'Trout'
+const Status = z.enum(['pending', 'done', 'cancelled'])
+type Status = z.infer<typeof Status>  // 'pending' | 'done' | 'cancelled'
 
 // Native enum
-enum Fruits {
-  Apple,
-  Banana,
-}
-const FruitSchema = z.nativeEnum(Fruits)
+enum Fruits { Apple, Banana }
+z.nativeEnum(Fruits)
 ```
 
-## Record
+## Record/Map/Set
 
 ```typescript
-const UserStore = z.record(z.string(), z.object({
-  name: z.string(),
-}))
-
-type UserStore = z.infer<typeof UserStore>
+z.record(z.string(), z.object({ name: z.string() }))
 // { [key: string]: { name: string } }
 
-// 사용
-const userStore: UserStore = {}
-userStore['77d2586b-9e8e-4ecf-8b21-ea7e0530eadd'] = {
-  name: 'Carlotta',
-} // passes
-
-userStore['77d2586b-9e8e-4ecf-8b21-ea7e0530eadd'] = {
-  whatever: 'Ice cream sundae',
-} // TypeError
+z.map(z.string(), z.number())  // Map<string, number>
+z.set(z.number())              // Set<number>
 ```
 
-## Map & Set
+## 재귀 스키마
 
 ```typescript
-// Map
-const stringNumberMap = z.map(z.string(), z.number())
-type StringNumberMap = z.infer<typeof stringNumberMap>
-// Map<string, number>
-
-// Set
-const numberSet = z.set(z.number())
-type NumberSet = z.infer<typeof numberSet>
-// Set<number>
-```
-
-## 재귀 스키마 (JSON)
-
-```typescript
-const literalSchema = z.union([z.string(), z.number(), z.boolean(), z.null()])
-type Literal = z.infer<typeof literalSchema>
-type Json = Literal | { [key: string]: Json } | Json[]
+type Json = string | number | boolean | null | { [key: string]: Json } | Json[]
 
 const jsonSchema: z.ZodType<Json> = z.lazy(() =>
-  z.union([literalSchema, z.array(jsonSchema), z.record(jsonSchema)])
+  z.union([
+    z.string(), z.number(), z.boolean(), z.null(),
+    z.array(jsonSchema),
+    z.record(jsonSchema)
+  ])
 )
-
-jsonSchema.parse({ foo: [1, 2, { bar: 'baz' }] })
 ```