timsquad 2.0.0

package/templates/common/claude/skills/coding/SKILL.md

@@ -0,0 +1,171 @@
+---
+name: coding
+description: 코드 작성 규칙 및 패턴 가이드라인
+user-invocable: false
+---
+
+<skill name="coding">
+  <purpose>일관된 고품질 코드 작성을 위한 가이드라인</purpose>
+
+  <naming-conventions>
+    <convention target="클래스" rule="PascalCase">
+      <example correct="true">UserService, OrderRepository</example>
+      <example correct="false">userService, user_service</example>
+    </convention>
+    <convention target="함수/메서드" rule="camelCase">
+      <example correct="true">getUserById, calculateTotal</example>
+      <example correct="false">GetUserById, get_user_by_id</example>
+    </convention>
+    <convention target="변수" rule="camelCase">
+      <example correct="true">userName, totalAmount</example>
+      <example correct="false">UserName, user_name</example>
+    </convention>
+    <convention target="상수" rule="UPPER_SNAKE">
+      <example correct="true">MAX_RETRY_COUNT, API_BASE_URL</example>
+      <example correct="false">maxRetryCount, MaxRetryCount</example>
+    </convention>
+    <convention target="파일" rule="kebab-case">
+      <example correct="true">user-service.ts, order-repository.ts</example>
+      <example correct="false">userService.ts, UserService.ts</example>
+    </convention>
+  </naming-conventions>
+
+  <function-principles>
+    <principle name="단일 책임">함수는 한 가지 일만 수행</principle>
+    <principle name="명확한 이름">함수 이름만으로 동작 파악 가능</principle>
+    <principle name="적절한 크기">20줄 이내 권장</principle>
+    <examples>
+      <example type="good">
+        <![CDATA[
+function calculateOrderTotal(items: OrderItem[]): number {
+  return items.reduce((sum, item) => sum + item.price * item.quantity, 0);
+}
+        ]]>
+        <description>단일 책임, 명확한 이름</description>
+      </example>
+      <example type="bad">
+        <![CDATA[
+function processOrder(order: Order): void {
+  // 가격 계산 + 재고 확인 + 결제 처리 + 알림 전송...
+}
+        ]]>
+        <description>여러 책임, 모호한 이름</description>
+      </example>
+    </examples>
+  </function-principles>
+
+  <error-handling>
+    <example type="good">
+      <![CDATA[
+async function getUser(id: string): Promise<User> {
+  const user = await userRepository.findById(id);
+  if (!user) {
+    throw new NotFoundError('USER_NOT_FOUND', `User ${id} not found`);
+  }
+  return user;
+}
+      ]]>
+      <description>명시적 에러 처리</description>
+    </example>
+    <example type="bad">
+      <![CDATA[
+async function getUser(id: string): Promise<User | null> {
+  try {
+    return await userRepository.findById(id);
+  } catch {
+    return null; // 에러 원인 알 수 없음
+  }
+}
+      ]]>
+      <description>에러 무시</description>
+    </example>
+  </error-handling>
+
+  <patterns>
+    <pattern name="Repository">
+      <purpose>데이터 접근 추상화</purpose>
+      <example>
+        <![CDATA[
+interface UserRepository {
+  findById(id: string): Promise<User | null>;
+  findByEmail(email: string): Promise<User | null>;
+  save(user: User): Promise<User>;
+  delete(id: string): Promise<void>;
+}
+
+class PostgresUserRepository implements UserRepository {
+  async findById(id: string): Promise<User | null> {
+    // PostgreSQL 구현
+  }
+}
+        ]]>
+      </example>
+    </pattern>
+    <pattern name="DTO/Entity 분리">
+      <purpose>레이어 간 데이터 전달</purpose>
+      <example>
+        <![CDATA[
+// Entity (도메인)
+class User {
+  constructor(
+    public readonly id: string,
+    public email: string,
+    public passwordHash: string, // 민감 정보
+  ) {}
+}
+
+// DTO (외부 노출)
+interface UserResponseDto {
+  id: string;
+  email: string;
+  // passwordHash 제외
+}
+        ]]>
+      </example>
+    </pattern>
+    <pattern name="의존성 주입">
+      <purpose>테스트 용이성, 유연한 구성</purpose>
+      <example type="good">
+        <![CDATA[
+class UserService {
+  constructor(private userRepository: UserRepository) {}
+}
+        ]]>
+      </example>
+      <example type="bad">
+        <![CDATA[
+class UserService {
+  private userRepository = new PostgresUserRepository();
+}
+        ]]>
+      </example>
+    </pattern>
+  </patterns>
+
+  <anti-patterns>
+    <anti-pattern name="any 타입">
+      <bad>function process(data: any): any { ... }</bad>
+      <good>function process&lt;T&gt;(data: T): ProcessedData&lt;T&gt; { ... }</good>
+    </anti-pattern>
+    <anti-pattern name="매직 넘버">
+      <bad>if (status === 1) { ... }</bad>
+      <good>
+        const Status = { ACTIVE: 1, INACTIVE: 0 } as const;
+        if (status === Status.ACTIVE) { ... }
+      </good>
+    </anti-pattern>
+    <anti-pattern name="콘솔 로그">
+      <bad>console.log('user:', user);</bad>
+      <good>logger.debug('User fetched', { userId: user.id });</good>
+    </anti-pattern>
+  </anti-patterns>
+
+  <checklist>
+    <item>함수가 단일 책임을 가지는가</item>
+    <item>네이밍이 명확하고 일관적인가</item>
+    <item>에러가 명시적으로 처리되는가</item>
+    <item>any 타입이 없는가</item>
+    <item>매직 넘버/문자열이 없는가</item>
+    <item>console.log가 없는가</item>
+  </checklist>
+</skill>

package/templates/common/claude/skills/database/prisma/SKILL.md

@@ -0,0 +1,357 @@
+---
+name: prisma
+description: Prisma ORM 개발 가이드라인
+user-invocable: false
+---
+
+<skill name="prisma">
+  <purpose>Prisma ORM을 활용한 타입 안전 데이터베이스 개발 가이드라인</purpose>
+
+  <philosophy>
+    <principle>Schema as SSOT - 스키마가 진실의 원천</principle>
+    <principle>Type Safety - 자동 생성 타입 활용</principle>
+    <principle>Migration First - 스키마 변경은 마이그레이션으로</principle>
+  </philosophy>
+
+  <schema-design>
+    <pattern name="기본 모델 정의">
+      <example>
+        <![CDATA[
+// prisma/schema.prisma
+
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+model User {
+  id        String   @id @default(cuid())
+  email     String   @unique
+  name      String
+  password  String
+  role      Role     @default(USER)
+
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  // Relations
+  posts     Post[]
+  profile   Profile?
+
+  @@index([email])
+  @@map("users")  // 테이블명
+}
+
+model Post {
+  id        String   @id @default(cuid())
+  title     String
+  content   String?
+  published Boolean  @default(false)
+
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  // Relations
+  author    User     @relation(fields: [authorId], references: [id])
+  authorId  String
+
+  @@index([authorId])
+  @@map("posts")
+}
+
+enum Role {
+  USER
+  ADMIN
+}
+        ]]>
+      </example>
+    </pattern>
+
+    <pattern name="공통 필드 패턴">
+      <description>모든 모델에 공통으로 들어가는 필드</description>
+      <example>
+        <![CDATA[
+// 공통 필드 패턴 (Prisma는 상속 미지원, 컨벤션으로 관리)
+// id        String   @id @default(cuid())
+// createdAt DateTime @default(now())
+// updatedAt DateTime @updatedAt
+
+model BaseFields {
+  // 참고용 - 실제 모델에 복사해서 사용
+  id        String   @id @default(cuid())
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+        ]]>
+      </example>
+    </pattern>
+
+    <pattern name="소프트 삭제">
+      <example>
+        <![CDATA[
+model User {
+  id        String    @id @default(cuid())
+  // ...
+  deletedAt DateTime? // null이면 활성, 값 있으면 삭제됨
+
+  @@index([deletedAt])
+}
+
+// 쿼리 시 필터링
+const activeUsers = await prisma.user.findMany({
+  where: { deletedAt: null },
+});
+        ]]>
+      </example>
+    </pattern>
+  </schema-design>
+
+  <client-setup>
+    <pattern name="싱글톤 인스턴스">
+      <example>
+        <![CDATA[
+// lib/prisma.ts
+import { PrismaClient } from '@prisma/client';
+
+const globalForPrisma = globalThis as unknown as {
+  prisma: PrismaClient | undefined;
+};
+
+export const prisma = globalForPrisma.prisma ?? new PrismaClient({
+  log: process.env.NODE_ENV === 'development'
+    ? ['query', 'error', 'warn']
+    : ['error'],
+});
+
+if (process.env.NODE_ENV !== 'production') {
+  globalForPrisma.prisma = prisma;
+}
+        ]]>
+      </example>
+    </pattern>
+
+    <pattern name="확장 (Extensions)">
+      <example>
+        <![CDATA[
+// lib/prisma.ts
+import { PrismaClient } from '@prisma/client';
+
+const prismaBase = new PrismaClient();
+
+export const prisma = prismaBase.$extends({
+  query: {
+    // 모든 findMany에 소프트 삭제 필터 자동 적용
+    $allModels: {
+      async findMany({ model, operation, args, query }) {
+        args.where = { ...args.where, deletedAt: null };
+        return query(args);
+      },
+    },
+  },
+});
+        ]]>
+      </example>
+    </pattern>
+  </client-setup>
+
+  <query-patterns>
+    <pattern name="기본 CRUD">
+      <example>
+        <![CDATA[
+// Create
+const user = await prisma.user.create({
+  data: {
+    email: 'test@example.com',
+    name: 'Test User',
+    password: hashedPassword,
+  },
+});
+
+// Read
+const user = await prisma.user.findUnique({
+  where: { id: userId },
+});
+
+const users = await prisma.user.findMany({
+  where: { role: 'USER' },
+  orderBy: { createdAt: 'desc' },
+  take: 10,
+  skip: 0,
+});
+
+// Update
+const updated = await prisma.user.update({
+  where: { id: userId },
+  data: { name: 'New Name' },
+});
+
+// Delete
+await prisma.user.delete({
+  where: { id: userId },
+});
+        ]]>
+      </example>
+    </pattern>
+
+    <pattern name="Relations 로딩">
+      <example>
+        <![CDATA[
+// include: 관계 데이터 포함
+const userWithPosts = await prisma.user.findUnique({
+  where: { id: userId },
+  include: {
+    posts: true,
+    profile: true,
+  },
+});
+
+// select: 특정 필드만 선택 (성능 최적화)
+const userWithPosts = await prisma.user.findUnique({
+  where: { id: userId },
+  select: {
+    id: true,
+    name: true,
+    posts: {
+      select: {
+        id: true,
+        title: true,
+      },
+      where: { published: true },
+      take: 5,
+    },
+  },
+});
+        ]]>
+      </example>
+    </pattern>
+
+    <pattern name="트랜잭션">
+      <example>
+        <![CDATA[
+// Interactive Transaction
+const result = await prisma.$transaction(async (tx) => {
+  // 1. 사용자 생성
+  const user = await tx.user.create({
+    data: { email, name, password },
+  });
+
+  // 2. 프로필 생성
+  const profile = await tx.profile.create({
+    data: { userId: user.id, bio: '' },
+  });
+
+  // 3. 웰컴 알림 생성
+  await tx.notification.create({
+    data: { userId: user.id, message: 'Welcome!' },
+  });
+
+  return user;
+});
+
+// 실패 시 모두 롤백
+        ]]>
+      </example>
+    </pattern>
+
+    <pattern name="Upsert">
+      <example>
+        <![CDATA[
+// 있으면 업데이트, 없으면 생성
+const user = await prisma.user.upsert({
+  where: { email: 'test@example.com' },
+  update: { name: 'Updated Name' },
+  create: { email: 'test@example.com', name: 'New User', password },
+});
+        ]]>
+      </example>
+    </pattern>
+  </query-patterns>
+
+  <migration>
+    <commands>
+      <command name="npx prisma migrate dev">개발 환경 마이그레이션 (자동 생성 + 적용)</command>
+      <command name="npx prisma migrate deploy">프로덕션 마이그레이션 적용</command>
+      <command name="npx prisma migrate reset">DB 초기화 + 모든 마이그레이션 재적용</command>
+      <command name="npx prisma db push">빠른 프로토타이핑 (마이그레이션 없이)</command>
+      <command name="npx prisma generate">클라이언트 재생성</command>
+    </commands>
+    <workflow>
+      <step>1. schema.prisma 수정</step>
+      <step>2. npx prisma migrate dev --name descriptive_name</step>
+      <step>3. 생성된 SQL 검토</step>
+      <step>4. 커밋 (schema.prisma + migrations/)</step>
+    </workflow>
+  </migration>
+
+  <repository-pattern>
+    <example>
+      <![CDATA[
+// domain/user/repository.ts
+export interface UserRepository {
+  findById(id: string): Promise<User | null>;
+  findByEmail(email: string): Promise<User | null>;
+  save(user: User): Promise<User>;
+  delete(id: string): Promise<void>;
+}
+
+// infrastructure/database/prisma-user-repository.ts
+import { prisma } from '@/lib/prisma';
+import { UserRepository } from '@/domain/user/repository';
+
+export class PrismaUserRepository implements UserRepository {
+  async findById(id: string) {
+    return prisma.user.findUnique({ where: { id } });
+  }
+
+  async findByEmail(email: string) {
+    return prisma.user.findUnique({ where: { email } });
+  }
+
+  async save(data: Omit<User, 'id' | 'createdAt' | 'updatedAt'>) {
+    return prisma.user.create({ data });
+  }
+
+  async delete(id: string) {
+    await prisma.user.delete({ where: { id } });
+  }
+}
+      ]]>
+    </example>
+  </repository-pattern>
+
+  <rules>
+    <category name="스키마">
+      <must>모든 모델에 id, createdAt, updatedAt</must>
+      <must>명시적 인덱스 정의</must>
+      <must>@@map으로 테이블명 명시</must>
+      <must>관계는 명확히 정의</must>
+    </category>
+    <category name="쿼리">
+      <must>select로 필요한 필드만 조회 (성능)</must>
+      <must>페이지네이션 적용 (take, skip)</must>
+      <must>복잡한 작업은 트랜잭션 사용</must>
+      <must-not>N+1 쿼리 (include/select 사용)</must-not>
+      <must-not>무한 결과 조회</must-not>
+    </category>
+    <category name="마이그레이션">
+      <must>migrate dev로 개발</must>
+      <must>migrate deploy로 배포</must>
+      <must>마이그레이션 파일 커밋</must>
+      <must-not>프로덕션에서 db push 사용</must-not>
+    </category>
+  </rules>
+
+  <checklist>
+    <item priority="critical">싱글톤 인스턴스 사용</item>
+    <item priority="critical">마이그레이션으로 스키마 관리</item>
+    <item priority="critical">트랜잭션으로 데이터 정합성</item>
+    <item priority="high">select로 필요한 필드만 조회</item>
+    <item priority="high">인덱스 적절히 설정</item>
+    <item priority="high">Repository 패턴 적용</item>
+    <item priority="medium">소프트 삭제 고려</item>
+  </checklist>
+</skill>