bitbucket-gemini-action 1.0.0

package/src/gemini/presets.ts

@@ -0,0 +1,2130 @@
+/**
+ * Review Presets
+ * Predefined review configurations for different contexts, experience levels, and frameworks
+ */
+
+export interface ReviewPreset {
+  name: string;
+  description: string;
+  prompt: string;
+  tags: string[];
+}
+
+export type PresetCategory =
+  | "experience"
+  | "perspective"
+  | "framework"
+  | "domain"
+  | "language"
+  | "quality"
+  | "ai";
+
+export interface PresetRegistry {
+  [key: string]: ReviewPreset;
+}
+
+/**
+ * Experience Level Presets
+ * 개발자 경험 수준별 리뷰
+ */
+export const EXPERIENCE_PRESETS: PresetRegistry = {
+  junior: {
+    name: "주니어 개발자용",
+    description: "초보 개발자가 성장할 수 있도록 친절하고 교육적인 리뷰",
+    tags: ["experience", "beginner"],
+    prompt: `주니어 개발자를 위한 교육적인 코드 리뷰를 제공해주세요:
+
+## 리뷰 스타일
+- 친절하고 격려하는 톤 사용
+- 모든 피드백에 "왜"를 설명
+- 기본 개념이 부족해 보이면 간단히 설명 추가
+- 좋은 부분도 칭찬하여 자신감 부여
+
+## 중점 검토 사항
+1. **기본기 확인**
+   - 변수/함수 네이밍이 명확한가?
+   - 코드 가독성이 좋은가?
+   - 주석이 적절한가?
+
+2. **일반적인 실수 체크**
+   - null/undefined 처리
+   - 에러 핸들링 누락
+   - 하드코딩된 값
+   - 중복 코드
+
+3. **학습 기회 제공**
+   - 더 나은 패턴 소개 (이유와 함께)
+   - 관련 문서/자료 링크 제안
+   - 단계별 개선 방법 제시
+
+## 피드백 형식
+- ✅ 잘한 점: [구체적 칭찬]
+- 📚 학습 포인트: [개념 설명 + 개선 방향]
+- 💡 팁: [실무에서 유용한 조언]`,
+  },
+
+  middle: {
+    name: "미들급 개발자용",
+    description: "중급 개발자의 성장을 위한 심화 리뷰",
+    tags: ["experience", "intermediate"],
+    prompt: `중급 개발자를 위한 심화 코드 리뷰를 제공해주세요:
+
+## 리뷰 스타일
+- 동등한 개발자로서 토론하는 톤
+- 트레이드오프 관점에서 분석
+- 대안 제시 시 각각의 장단점 설명
+
+## 중점 검토 사항
+1. **설계 패턴 및 원칙**
+   - SOLID 원칙 준수 여부
+   - 적절한 디자인 패턴 사용
+   - 의존성 관리 및 결합도
+
+2. **코드 품질 심화**
+   - 테스트 용이성 (Testability)
+   - 확장성 고려
+   - 재사용 가능성
+
+3. **성능 및 최적화**
+   - 알고리즘 복잡도
+   - 메모리 사용 패턴
+   - 불필요한 연산 제거
+
+4. **실무 관점**
+   - 유지보수성
+   - 팀 협업 시 가독성
+   - 문서화 필요성
+
+## 피드백 형식
+- 🔍 분석: [현재 코드의 특성]
+- 🎯 제안: [개선 방향 + 이유]
+- ⚖️ 트레이드오프: [대안들의 장단점]`,
+  },
+
+  senior: {
+    name: "시니어 개발자용",
+    description: "고급 아키텍처 및 전략적 관점의 리뷰",
+    tags: ["experience", "advanced"],
+    prompt: `시니어 개발자를 위한 고급 코드 리뷰를 제공해주세요:
+
+## 리뷰 스타일
+- 간결하고 핵심적인 피드백
+- 아키텍처 수준의 인사이트
+- 장기적 관점의 제안
+
+## 중점 검토 사항
+1. **아키텍처 영향도**
+   - 시스템 전체에 미치는 영향
+   - 기존 아키텍처와의 일관성
+   - 기술 부채 발생 가능성
+
+2. **확장성 및 유연성**
+   - 향후 요구사항 변경 대응력
+   - 모듈화 및 경계 설정
+   - 인터페이스 설계
+
+3. **운영 관점**
+   - 모니터링/로깅 적절성
+   - 장애 복구 고려
+   - 배포 전략 영향
+
+4. **팀/조직 영향**
+   - 코드 컨벤션 준수
+   - 온보딩 용이성
+   - 지식 공유 관점
+
+## 피드백 형식
+- 🏗️ 아키텍처: [시스템 관점 분석]
+- ⚠️ 리스크: [잠재적 문제점]
+- 🚀 전략: [장기적 개선 방향]`,
+  },
+
+  lead: {
+    name: "테크 리드용",
+    description: "팀 리딩 관점의 전략적 리뷰",
+    tags: ["experience", "leadership"],
+    prompt: `테크 리드 관점의 전략적 코드 리뷰를 제공해주세요:
+
+## 리뷰 스타일
+- 팀 전체 관점에서 분석
+- 멘토링 기회 식별
+- 프로세스 개선점 도출
+
+## 중점 검토 사항
+1. **팀 역량 관점**
+   - 주니어 멤버 학습 기회
+   - 코드 리뷰 문화 개선점
+   - 페어 프로그래밍 필요성
+
+2. **표준화 및 일관성**
+   - 팀 컨벤션 준수
+   - 공통 패턴 적용
+   - 문서화 표준
+
+3. **기술 부채 관리**
+   - 즉시 수정 필요 사항
+   - 백로그 등록 필요 사항
+   - 리팩토링 계획 제안
+
+4. **프로젝트 영향**
+   - 일정 영향도
+   - 리스크 평가
+   - 다른 팀과의 인터페이스`,
+  },
+};
+
+/**
+ * Perspective Presets
+ * 리뷰 관점별 프리셋
+ */
+export const PERSPECTIVE_PRESETS: PresetRegistry = {
+  architecture: {
+    name: "아키텍처/설계",
+    description: "소프트웨어 설계 및 아키텍처 관점 리뷰",
+    tags: ["perspective", "design"],
+    prompt: `소프트웨어 아키텍처 관점에서 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 설계 원칙
+- **SOLID 원칙**
+  - Single Responsibility: 클래스/함수의 단일 책임
+  - Open/Closed: 확장에 열림, 수정에 닫힘
+  - Liskov Substitution: 하위 타입 치환 가능성
+  - Interface Segregation: 인터페이스 분리
+  - Dependency Inversion: 의존성 역전
+
+- **기타 원칙**
+  - DRY (Don't Repeat Yourself)
+  - KISS (Keep It Simple, Stupid)
+  - YAGNI (You Ain't Gonna Need It)
+
+### 2. 아키텍처 패턴
+- 레이어 분리 적절성
+- 도메인 모델 설계
+- 의존성 방향 (안쪽으로 향하는지)
+- 경계 컨텍스트 식별
+
+### 3. 모듈화
+- 응집도 (Cohesion) - 높을수록 좋음
+- 결합도 (Coupling) - 낮을수록 좋음
+- 인터페이스 정의
+- 캡슐화 수준
+
+### 4. 확장 포인트
+- 플러그인/확장 가능한 구조
+- 설정의 외부화
+- 전략 패턴 적용 가능성`,
+  },
+
+  security: {
+    name: "보안",
+    description: "보안 취약점 및 안전한 코딩 관점 리뷰",
+    tags: ["perspective", "security"],
+    prompt: `보안 관점에서 코드를 철저히 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 입력 검증
+- 모든 사용자 입력 검증 여부
+- 화이트리스트 vs 블랙리스트 접근
+- 입력 길이/형식 제한
+- 파일 업로드 검증
+
+### 2. 인젝션 공격
+- **SQL Injection**: 파라미터화된 쿼리 사용
+- **XSS**: 출력 인코딩, CSP 헤더
+- **Command Injection**: 셸 명령 실행 검증
+- **LDAP/XML Injection**: 특수문자 처리
+
+### 3. 인증/인가
+- 인증 로직 우회 가능성
+- 권한 검사 누락
+- 세션 관리 취약점
+- JWT/토큰 처리 안전성
+
+### 4. 민감 데이터
+- 비밀번호 평문 저장 여부
+- API 키/시크릿 노출
+- 로그에 민감정보 출력
+- 암호화 적절성 (알고리즘, 키 관리)
+
+### 5. 기타 보안
+- CSRF 방어
+- 안전하지 않은 직접 객체 참조 (IDOR)
+- 레이스 컨디션
+- 에러 메시지 정보 노출
+
+## 심각도 표시
+- 🔴 Critical: 즉시 수정 필요
+- 🟠 High: 배포 전 수정 필요
+- 🟡 Medium: 조속한 수정 권장
+- 🟢 Low: 개선 권장`,
+  },
+
+  performance: {
+    name: "성능",
+    description: "성능 최적화 관점 리뷰",
+    tags: ["perspective", "optimization"],
+    prompt: `성능 최적화 관점에서 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 알고리즘 복잡도
+- 시간 복잡도 (Big O)
+- 공간 복잡도
+- 더 효율적인 알고리즘 존재 여부
+- 불필요한 반복/재계산
+
+### 2. 데이터베이스
+- **N+1 쿼리 문제**
+- 인덱스 활용 여부
+- 불필요한 SELECT *
+- 트랜잭션 범위 적절성
+- 커넥션 풀 관리
+
+### 3. 메모리 관리
+- 메모리 누수 가능성
+- 대용량 데이터 처리 방식
+- 객체 생성 최소화
+- 캐싱 전략
+
+### 4. 네트워크
+- API 호출 최소화
+- 배치 처리 가능성
+- 압축 사용
+- 연결 재사용
+
+### 5. 비동기 처리
+- 블로킹 코드 식별
+- 병렬 처리 가능성
+- 적절한 타임아웃 설정
+- 백프레셔 처리
+
+### 6. 프론트엔드 (해당 시)
+- 번들 사이즈
+- 레이지 로딩
+- 메모이제이션
+- 리렌더링 최소화`,
+  },
+
+  testing: {
+    name: "테스트",
+    description: "테스트 품질 및 전략 관점 리뷰",
+    tags: ["perspective", "quality"],
+    prompt: `테스트 관점에서 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 테스트 커버리지
+- 핵심 로직 테스트 여부
+- 엣지 케이스 커버
+- 에러 케이스 테스트
+- 경계값 테스트
+
+### 2. 테스트 품질
+- **AAA 패턴**: Arrange, Act, Assert
+- 테스트 독립성
+- 테스트 가독성
+- 테스트 이름의 명확성
+
+### 3. 테스트 유형
+- 단위 테스트 적절성
+- 통합 테스트 필요성
+- E2E 테스트 시나리오
+- 스냅샷 테스트 (UI)
+
+### 4. 모킹 전략
+- 적절한 모킹 수준
+- 과도한 모킹 여부
+- 테스트 더블 사용 (Stub, Mock, Spy)
+- 외부 의존성 격리
+
+### 5. 테스트 유지보수
+- 테스트 코드 중복
+- 테스트 헬퍼/유틸리티
+- 픽스처 관리
+- 테스트 데이터 관리
+
+### 6. 테스트 가능성
+- 코드의 테스트 용이성
+- 의존성 주입 활용
+- 순수 함수 분리`,
+  },
+
+  accessibility: {
+    name: "접근성 (a11y)",
+    description: "웹 접근성 관점 리뷰",
+    tags: ["perspective", "a11y", "frontend"],
+    prompt: `웹 접근성(a11y) 관점에서 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 시맨틱 HTML
+- 적절한 HTML 태그 사용
+- 헤딩 계층 구조
+- 랜드마크 영역 (header, nav, main, footer)
+- 리스트/테이블 구조
+
+### 2. ARIA
+- aria-label, aria-labelledby 사용
+- aria-live 영역 (동적 콘텐츠)
+- role 속성 적절성
+- aria-hidden 처리
+
+### 3. 키보드 접근성
+- 모든 인터랙티브 요소 키보드 접근 가능
+- 포커스 순서 논리적
+- 포커스 표시 visible
+- 키보드 트랩 방지
+
+### 4. 시각적 접근성
+- 색상 대비 (WCAG 기준)
+- 색상만으로 정보 전달 X
+- 텍스트 크기 조절 가능
+- 애니메이션 제어 (prefers-reduced-motion)
+
+### 5. 폼 접근성
+- label과 input 연결
+- 에러 메시지 명확
+- 필수 필드 표시
+- 자동완성 속성
+
+### 6. 이미지/미디어
+- alt 텍스트 적절성
+- 장식 이미지 처리
+- 비디오 자막
+- 오디오 대체 텍스트`,
+  },
+
+  errorHandling: {
+    name: "에러 핸들링",
+    description: "에러 처리 및 예외 관리 관점 리뷰",
+    tags: ["perspective", "reliability"],
+    prompt: `에러 핸들링 관점에서 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 예외 처리 기본
+- try-catch 적절한 범위
+- 구체적인 예외 타입 사용
+- 빈 catch 블록 금지
+- finally 블록 활용
+
+### 2. 에러 전파
+- 에러 래핑 및 컨텍스트 추가
+- 에러 체이닝
+- 적절한 추상화 수준의 에러
+- 호출자에게 유용한 정보 제공
+
+### 3. 사용자 피드백
+- 사용자 친화적 에러 메시지
+- 기술적 세부사항 숨김
+- 복구 방법 안내
+- 일관된 에러 형식
+
+### 4. 로깅 및 모니터링
+- 적절한 로그 레벨
+- 에러 컨텍스트 로깅
+- 스택 트레이스 보존
+- 알림 설정 고려
+
+### 5. 복구 전략
+- 재시도 로직
+- 폴백 메커니즘
+- 서킷 브레이커 패턴
+- 그레이스풀 디그레이데이션
+
+### 6. 비동기 에러
+- Promise rejection 처리
+- async/await 에러 처리
+- 이벤트 에러 핸들링
+- 스트림 에러 처리`,
+  },
+
+  codeStyle: {
+    name: "코드 스타일/컨벤션",
+    description: "코드 스타일 및 일관성 관점 리뷰",
+    tags: ["perspective", "style"],
+    prompt: `코드 스타일과 컨벤션 관점에서 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 네이밍
+- 변수/함수/클래스 이름의 명확성
+- 일관된 네이밍 컨벤션 (camelCase, PascalCase 등)
+- 축약어 사용 최소화
+- 의미 있는 이름 사용
+
+### 2. 코드 구조
+- 함수 길이 (20-30줄 이하 권장)
+- 파일 길이 적절성
+- 들여쓰기 일관성
+- 빈 줄 사용으로 논리적 분리
+
+### 3. 주석
+- 필요한 곳에 주석 존재
+- 불필요한 주석 제거
+- TODO/FIXME 적절한 사용
+- JSDoc/TSDoc 문서화
+
+### 4. 가독성
+- 복잡한 조건문 단순화
+- 매직 넘버 상수화
+- 깊은 중첩 피하기
+- Early return 패턴
+
+### 5. 일관성
+- 팀 컨벤션 준수
+- 기존 코드베이스와 일관성
+- import 순서
+- 파일 구조`,
+  },
+};
+
+/**
+ * Framework Presets
+ * 프레임워크별 프리셋
+ */
+export const FRAMEWORK_PRESETS: PresetRegistry = {
+  react: {
+    name: "React",
+    description: "React 베스트 프랙티스 기반 리뷰",
+    tags: ["framework", "frontend", "react"],
+    prompt: `React 베스트 프랙티스 기준으로 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 컴포넌트 설계
+- 단일 책임 원칙
+- 컴포넌트 크기 적절성
+- Presentational vs Container 분리
+- 합성(Composition) 활용
+
+### 2. Hooks 사용
+- **useState**: 적절한 상태 분리
+- **useEffect**: 의존성 배열 정확성, 클린업 함수
+- **useMemo/useCallback**: 필요한 곳에만 사용
+- **useRef**: DOM 접근 vs 값 저장 구분
+- 커스텀 훅 추출 기회
+
+### 3. 상태 관리
+- 로컬 vs 전역 상태 구분
+- 상태 끌어올리기 적절성
+- 불필요한 상태 제거
+- 파생 상태 계산
+
+### 4. 성능 최적화
+- 불필요한 리렌더링 방지
+- React.memo 적절한 사용
+- 키(key) 올바른 사용
+- 코드 스플리팅
+
+### 5. 패턴
+- Controlled vs Uncontrolled 컴포넌트
+- Render Props / HOC / Hooks 선택
+- Error Boundary 사용
+- Suspense 활용
+
+### 6. TypeScript (해당 시)
+- Props 타입 정의
+- 제네릭 컴포넌트
+- 이벤트 타입`,
+  },
+
+  nextjs: {
+    name: "Next.js",
+    description: "Next.js App Router 베스트 프랙티스 기반 리뷰",
+    tags: ["framework", "frontend", "nextjs", "react"],
+    prompt: `Next.js (App Router) 베스트 프랙티스 기준으로 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. Server vs Client Components
+- 'use client' 지시어 최소화
+- 서버 컴포넌트에서 데이터 페칭
+- 클라이언트 컴포넌트 경계 설정
+- 인터리빙 패턴
+
+### 2. Data Fetching
+- **Server Components**: async/await 직접 사용
+- **Server Actions**: 폼 처리, 뮤테이션
+- fetch 캐싱 전략 (cache, revalidate)
+- 병렬 데이터 페칭
+
+### 3. 라우팅
+- 파일 기반 라우팅 구조
+- 동적 라우트 적절성
+- Route Groups 활용
+- Parallel/Intercepting Routes
+
+### 4. 메타데이터
+- generateMetadata 사용
+- 동적 OG 이미지
+- sitemap, robots.txt
+
+### 5. 최적화
+- **Image**: next/image 사용, sizes 속성
+- **Font**: next/font 사용
+- **Script**: next/script 전략
+- Static vs Dynamic 렌더링
+
+### 6. 캐싱 전략
+- Full Route Cache
+- Data Cache
+- Router Cache
+- revalidatePath/revalidateTag
+
+### 7. 에러 처리
+- error.tsx 바운더리
+- not-found.tsx
+- loading.tsx 스켈레톤`,
+  },
+
+  vue: {
+    name: "Vue.js",
+    description: "Vue 3 Composition API 베스트 프랙티스 기반 리뷰",
+    tags: ["framework", "frontend", "vue"],
+    prompt: `Vue 3 (Composition API) 베스트 프랙티스 기준으로 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. Composition API
+- setup() 또는 <script setup> 사용
+- ref vs reactive 적절한 선택
+- computed 활용
+- watch/watchEffect 사용
+
+### 2. 컴포넌트 설계
+- Props 정의 (타입, 기본값, 검증)
+- Emits 정의
+- v-model 커스텀
+- Slots 활용
+
+### 3. Composables
+- 재사용 가능한 로직 추출
+- 네이밍 컨벤션 (use 접두사)
+- 반응성 유지
+- 클린업 처리
+
+### 4. 성능
+- v-show vs v-if 선택
+- v-for 키 사용
+- 컴포넌트 지연 로딩
+- keep-alive 활용
+
+### 5. 상태 관리 (Pinia)
+- Store 구조
+- Actions vs Getters
+- 구독 및 플러그인
+
+### 6. TypeScript
+- defineProps/defineEmits 타입
+- 제네릭 컴포넌트`,
+  },
+
+  angular: {
+    name: "Angular",
+    description: "Angular 베스트 프랙티스 기반 리뷰",
+    tags: ["framework", "frontend", "angular"],
+    prompt: `Angular 베스트 프랙티스 기준으로 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 컴포넌트
+- 스마트/덤 컴포넌트 분리
+- ChangeDetectionStrategy.OnPush 사용
+- 컴포넌트 크기 적절성
+- Input/Output 데코레이터
+
+### 2. 모듈 구조
+- Feature 모듈 분리
+- Shared 모듈 활용
+- Lazy Loading 적용
+- Standalone Components
+
+### 3. 서비스 및 DI
+- 싱글톤 vs 컴포넌트 스코프
+- providedIn 설정
+- 인터페이스 기반 설계
+
+### 4. RxJS
+- Observable 구독 관리
+- takeUntil/async pipe 사용
+- 에러 핸들링
+- 적절한 오퍼레이터 선택
+
+### 5. 폼
+- Reactive Forms vs Template Forms
+- 폼 검증 로직
+- 커스텀 Validator
+
+### 6. 성능
+- TrackBy 함수
+- 순수 Pipe
+- Zone.js 최적화`,
+  },
+
+  nestjs: {
+    name: "NestJS",
+    description: "NestJS 베스트 프랙티스 기반 리뷰",
+    tags: ["framework", "backend", "nestjs", "node"],
+    prompt: `NestJS 베스트 프랙티스 기준으로 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 모듈 구조
+- 모듈 경계 명확성
+- 순환 의존성 방지
+- Dynamic Modules 활용
+- Global 모듈 최소화
+
+### 2. 의존성 주입
+- Provider 스코프 (DEFAULT, REQUEST, TRANSIENT)
+- 커스텀 Provider
+- 인터페이스 기반 주입
+- useFactory/useClass/useValue
+
+### 3. 컨트롤러
+- REST 규칙 준수
+- 라우트 네이밍
+- HTTP 상태 코드 적절성
+- API 버저닝
+
+### 4. 서비스
+- 비즈니스 로직 분리
+- 트랜잭션 관리
+- 캐싱 전략
+
+### 5. 미들웨어/가드/인터셉터/파이프
+- 적절한 레이어 선택
+- Guard: 인증/인가
+- Interceptor: 로깅, 변환
+- Pipe: 검증, 변환
+
+### 6. DTO 및 검증
+- class-validator 데코레이터
+- class-transformer 활용
+- 화이트리스트 검증
+- 커스텀 Validator
+
+### 7. 예외 처리
+- HttpException 활용
+- 커스텀 Exception Filter
+- 에러 응답 일관성
+
+### 8. TypeORM/Prisma
+- Repository 패턴
+- 쿼리 최적화
+- 마이그레이션 관리`,
+  },
+
+  express: {
+    name: "Express.js",
+    description: "Express.js 베스트 프랙티스 기반 리뷰",
+    tags: ["framework", "backend", "express", "node"],
+    prompt: `Express.js 베스트 프랙티스 기준으로 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 라우팅
+- Router 모듈화
+- RESTful 규칙 준수
+- 라우트 네이밍 일관성
+- 버저닝 전략
+
+### 2. 미들웨어
+- 미들웨어 순서
+- 에러 핸들링 미들웨어
+- 커스텀 미들웨어 구조
+- async 미들웨어 처리
+
+### 3. 보안
+- helmet 사용
+- CORS 설정
+- Rate Limiting
+- 입력 검증 (express-validator)
+
+### 4. 에러 처리
+- 중앙 집중식 에러 핸들러
+- 커스텀 에러 클래스
+- 운영/개발 에러 분리
+- 비동기 에러 캐치
+
+### 5. 구조
+- MVC 또는 레이어드 아키텍처
+- 설정 관리
+- 환경 변수 처리
+- 로깅 전략
+
+### 6. 성능
+- 압축 (compression)
+- 캐싱 헤더
+- 클러스터링
+- 커넥션 풀링`,
+  },
+
+  fastify: {
+    name: "Fastify",
+    description: "Fastify 베스트 프랙티스 기반 리뷰",
+    tags: ["framework", "backend", "fastify", "node"],
+    prompt: `Fastify 베스트 프랙티스 기준으로 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 플러그인 시스템
+- 플러그인 캡슐화
+- fastify-plugin 사용
+- 데코레이터 활용
+- 플러그인 순서
+
+### 2. 스키마 검증
+- JSON Schema 정의
+- 응답 스키마
+- 쿼리/파라미터 스키마
+- 공유 스키마 ($ref)
+
+### 3. 직렬화
+- fast-json-stringify 활용
+- 응답 직렬화 최적화
+
+### 4. 훅
+- 라이프사이클 훅 활용
+- onRequest, preHandler, onSend
+- 에러 훅
+
+### 5. 타입 안전성
+- TypeBox 또는 Typebox
+- 타입 프로바이더
+- 제네릭 라우트`,
+  },
+
+  springboot: {
+    name: "Spring Boot",
+    description: "Spring Boot 베스트 프랙티스 기반 리뷰",
+    tags: ["framework", "backend", "java", "spring"],
+    prompt: `Spring Boot 베스트 프랙티스 기준으로 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 레이어 구조
+- Controller → Service → Repository 분리
+- DTO vs Entity 분리
+- 도메인 로직 위치
+
+### 2. 의존성 주입
+- 생성자 주입 선호
+- @Autowired 필드 주입 지양
+- 인터페이스 기반 설계
+
+### 3. REST API
+- @RestController 사용
+- ResponseEntity 활용
+- HTTP 상태 코드
+- API 버저닝
+
+### 4. 검증
+- @Valid, @Validated
+- 커스텀 Validator
+- BindingResult 처리
+
+### 5. 예외 처리
+- @ControllerAdvice
+- @ExceptionHandler
+- 커스텀 예외 클래스
+
+### 6. JPA/Hibernate
+- 지연 로딩 vs 즉시 로딩
+- N+1 문제 해결 (fetch join, @EntityGraph)
+- 트랜잭션 범위
+- 영속성 컨텍스트
+
+### 7. 보안
+- Spring Security 설정
+- 인증/인가 분리
+- CSRF, CORS
+
+### 8. 설정
+- application.yml 구조
+- 프로파일 관리
+- 외부 설정`,
+  },
+
+  django: {
+    name: "Django",
+    description: "Django 베스트 프랙티스 기반 리뷰",
+    tags: ["framework", "backend", "python", "django"],
+    prompt: `Django 베스트 프랙티스 기준으로 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 프로젝트 구조
+- 앱 분리 원칙
+- 설정 파일 구조
+- URL 라우팅
+
+### 2. 모델
+- 필드 타입 적절성
+- 인덱스 설정
+- Manager 커스터마이징
+- 시그널 사용
+
+### 3. 뷰
+- CBV vs FBV 선택
+- Mixin 활용
+- 권한 처리
+
+### 4. ORM
+- QuerySet 최적화
+- select_related/prefetch_related
+- 집계 함수 활용
+- Raw SQL 최소화
+
+### 5. 폼
+- ModelForm 활용
+- 커스텀 검증
+- 위젯 커스터마이징
+
+### 6. 보안
+- CSRF 보호
+- XSS 방지
+- SQL Injection 방지
+- 인증/인가
+
+### 7. Django REST Framework
+- Serializer 설계
+- ViewSet 활용
+- 권한 클래스
+- 페이지네이션`,
+  },
+
+  flask: {
+    name: "Flask",
+    description: "Flask 베스트 프랙티스 기반 리뷰",
+    tags: ["framework", "backend", "python", "flask"],
+    prompt: `Flask 베스트 프랙티스 기준으로 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 애플리케이션 팩토리
+- create_app 패턴
+- 설정 관리
+- 확장 초기화
+
+### 2. 블루프린트
+- 모듈화 구조
+- URL 프리픽스
+- 에러 핸들러
+
+### 3. 라우팅
+- 데코레이터 사용
+- URL 변수
+- HTTP 메서드
+
+### 4. 요청/응답
+- request 객체 활용
+- jsonify 사용
+- 에러 응답
+
+### 5. 데이터베이스
+- Flask-SQLAlchemy 사용
+- 세션 관리
+- 마이그레이션 (Flask-Migrate)
+
+### 6. 보안
+- Flask-Login
+- 비밀번호 해싱
+- CSRF 보호`,
+  },
+};
+
+/**
+ * Domain Presets
+ * 도메인/영역별 프리셋
+ */
+export const DOMAIN_PRESETS: PresetRegistry = {
+  frontend: {
+    name: "프론트엔드 일반",
+    description: "프론트엔드 개발 전반 관점 리뷰",
+    tags: ["domain", "frontend"],
+    prompt: `프론트엔드 개발 관점에서 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. UI/UX
+- 사용자 피드백 (로딩, 에러 상태)
+- 인터랙션 일관성
+- 폼 유효성 검사 UX
+- 반응형 디자인
+
+### 2. 상태 관리
+- 로컬/전역 상태 분리
+- 상태 정규화
+- 캐싱 전략
+- 낙관적 업데이트
+
+### 3. API 통신
+- 에러 핸들링
+- 로딩 상태 관리
+- 재시도 로직
+- 요청 취소
+
+### 4. 스타일링
+- CSS 방법론 (BEM, CSS Modules, CSS-in-JS)
+- 테마 시스템
+- 반응형 브레이크포인트
+- 다크모드 지원
+
+### 5. 빌드/번들
+- 트리 쉐이킹
+- 코드 스플리팅
+- 환경 변수 관리
+- 소스맵
+
+### 6. 브라우저 호환성
+- Polyfill 필요성
+- CSS 프리픽스
+- Feature Detection`,
+  },
+
+  backend: {
+    name: "백엔드 일반",
+    description: "백엔드 개발 전반 관점 리뷰",
+    tags: ["domain", "backend"],
+    prompt: `백엔드 개발 관점에서 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. API 설계
+- RESTful 원칙 준수
+- 엔드포인트 네이밍
+- HTTP 메서드 적절성
+- 상태 코드 사용
+- 버저닝 전략
+
+### 2. 데이터베이스
+- 스키마 설계
+- 인덱스 전략
+- 쿼리 최적화
+- 트랜잭션 관리
+- 커넥션 풀링
+
+### 3. 인증/인가
+- 인증 방식 (JWT, Session, OAuth)
+- 권한 체크 위치
+- 토큰 관리
+- 비밀번호 정책
+
+### 4. 비동기 처리
+- 큐 시스템 활용
+- 백그라운드 작업
+- 이벤트 기반 처리
+
+### 5. 캐싱
+- 캐시 전략 (Cache-Aside, Write-Through)
+- TTL 설정
+- 캐시 무효화
+- 분산 캐시
+
+### 6. 로깅/모니터링
+- 로그 레벨
+- 구조화된 로깅
+- 요청 추적
+- 메트릭 수집`,
+  },
+
+  fullstack: {
+    name: "풀스택",
+    description: "프론트엔드와 백엔드 전체 관점 리뷰",
+    tags: ["domain", "fullstack"],
+    prompt: `풀스택 관점에서 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. API 계약
+- 프론트-백 인터페이스 일관성
+- 타입 공유 (OpenAPI, GraphQL 스키마)
+- 에러 응답 형식 통일
+- 페이지네이션 표준
+
+### 2. 데이터 흐름
+- 클라이언트-서버 데이터 동기화
+- 실시간 업데이트 처리
+- 캐싱 전략 일관성
+- 낙관적 업데이트
+
+### 3. 인증 흐름
+- 토큰 저장 방식
+- 리프레시 토큰 처리
+- 세션 만료 UX
+- 로그아웃 처리
+
+### 4. 환경 설정
+- 환경 변수 관리
+- 시크릿 관리
+- 설정 검증
+
+### 5. 배포
+- 빌드 파이프라인
+- 환경별 설정
+- 마이그레이션 전략`,
+  },
+
+  mobile: {
+    name: "모바일 (React Native/Flutter)",
+    description: "크로스 플랫폼 모바일 앱 관점 리뷰",
+    tags: ["domain", "mobile"],
+    prompt: `모바일 앱 개발 관점에서 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 성능
+- 렌더링 최적화
+- 메모리 관리
+- 리스트 가상화
+- 이미지 최적화
+- 네이티브 모듈 사용
+
+### 2. UX
+- 제스처 핸들링
+- 애니메이션 부드러움
+- 오프라인 지원
+- 딥링킹
+
+### 3. 네이티브 연동
+- 플랫폼별 코드 분리
+- 권한 요청
+- 푸시 알림
+- 백그라운드 작업
+
+### 4. 상태 관리
+- 로컬 저장소 활용
+- 상태 지속성
+- 네비게이션 상태
+
+### 5. 테스트
+- 단위 테스트
+- 위젯/컴포넌트 테스트
+- E2E 테스트
+- 디바이스 테스트`,
+  },
+
+  devops: {
+    name: "DevOps/인프라",
+    description: "CI/CD, 인프라 코드 관점 리뷰",
+    tags: ["domain", "devops", "infrastructure"],
+    prompt: `DevOps/인프라 관점에서 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. CI/CD
+- 파이프라인 구조
+- 테스트 단계
+- 빌드 최적화
+- 배포 전략 (Blue-Green, Canary)
+
+### 2. IaC (Infrastructure as Code)
+- 모듈화
+- 상태 관리
+- 변수/시크릿 관리
+- 드리프트 방지
+
+### 3. 컨테이너
+- Dockerfile 최적화
+- 이미지 크기
+- 레이어 캐싱
+- 보안 스캐닝
+
+### 4. Kubernetes
+- 리소스 정의
+- 리소스 제한
+- 헬스 체크
+- 시크릿 관리
+
+### 5. 모니터링
+- 메트릭 수집
+- 로그 집계
+- 알림 설정
+- 대시보드`,
+  },
+
+  database: {
+    name: "데이터베이스",
+    description: "데이터베이스 스키마, 쿼리 최적화 관점 리뷰",
+    tags: ["domain", "database"],
+    prompt: `데이터베이스 관점에서 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 스키마 설계
+- 정규화 수준 적절성
+- 관계 설정
+- 데이터 타입 선택
+- NULL 허용 여부
+
+### 2. 인덱스
+- 인덱스 필요성
+- 복합 인덱스 순서
+- 인덱스 과다 사용
+- 커버링 인덱스
+
+### 3. 쿼리 최적화
+- 실행 계획 분석
+- N+1 문제
+- 서브쿼리 vs JOIN
+- LIMIT/OFFSET 주의
+
+### 4. 트랜잭션
+- 격리 수준
+- 데드락 방지
+- 트랜잭션 범위
+- 롤백 처리
+
+### 5. 마이그레이션
+- 무중단 마이그레이션
+- 롤백 계획
+- 데이터 백필`,
+  },
+};
+
+/**
+ * Language Presets
+ * 프로그래밍 언어별 프리셋
+ */
+export const LANGUAGE_PRESETS: PresetRegistry = {
+  typescript: {
+    name: "TypeScript",
+    description: "TypeScript 타입 시스템 및 베스트 프랙티스 리뷰",
+    tags: ["language", "typescript"],
+    prompt: `TypeScript 베스트 프랙티스 기준으로 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 타입 정의
+- any 사용 최소화
+- unknown vs any 선택
+- 타입 추론 활용
+- 명시적 타입 필요 여부
+
+### 2. 타입 안전성
+- null/undefined 처리
+- 타입 가드 사용
+- 타입 단언 최소화
+- never 타입 활용
+
+### 3. 제네릭
+- 제네릭 활용 기회
+- 제네릭 제약 조건
+- 조건부 타입
+- 매핑된 타입
+
+### 4. 인터페이스 vs 타입
+- 적절한 선택
+- 확장성 고려
+- 유니온/인터섹션 활용
+
+### 5. 유틸리티 타입
+- Partial, Required, Pick, Omit
+- Record, Readonly
+- ReturnType, Parameters
+
+### 6. 모듈
+- import/export 구조
+- 타입 전용 import
+- 배럴 파일`,
+  },
+
+  javascript: {
+    name: "JavaScript",
+    description: "모던 JavaScript 베스트 프랙티스 리뷰",
+    tags: ["language", "javascript"],
+    prompt: `모던 JavaScript 베스트 프랙티스 기준으로 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. ES6+ 문법
+- const/let 사용 (var 지양)
+- 화살표 함수 적절한 사용
+- 템플릿 리터럴
+- 구조 분해 할당
+- 스프레드 연산자
+
+### 2. 비동기 처리
+- async/await 패턴
+- Promise 체이닝
+- 에러 핸들링
+- 병렬 처리 (Promise.all)
+
+### 3. 배열/객체 메서드
+- map, filter, reduce 활용
+- find, findIndex, includes
+- Object.entries/keys/values
+- Optional chaining (?.)
+- Nullish coalescing (??)
+
+### 4. 모듈 시스템
+- ES Modules 사용
+- 동적 import
+- 네임드 vs 디폴트 export
+
+### 5. 클로저 및 스코프
+- 클로저 이해
+- this 바인딩
+- 호이스팅 주의`,
+  },
+
+  python: {
+    name: "Python",
+    description: "Python/PEP 스타일 가이드 기반 리뷰",
+    tags: ["language", "python"],
+    prompt: `Python (PEP 8) 베스트 프랙티스 기준으로 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. PEP 8 스타일
+- 네이밍 컨벤션 (snake_case)
+- 들여쓰기 (4 spaces)
+- 줄 길이 (79-120자)
+- import 순서
+
+### 2. Pythonic 코드
+- List comprehension
+- Generator expression
+- Context manager (with)
+- f-string 포매팅
+
+### 3. 타입 힌트
+- 함수 시그니처 타입
+- 변수 타입 힌트
+- typing 모듈 활용
+- mypy 호환성
+
+### 4. 예외 처리
+- 구체적인 예외 타입
+- 예외 체이닝 (from)
+- 커스텀 예외
+
+### 5. 클래스
+- @dataclass 활용
+- @property 데코레이터
+- __slots__ 최적화
+- ABC 추상 클래스
+
+### 6. 함수형
+- 순수 함수
+- functools 활용
+- 불변성 선호`,
+  },
+
+  go: {
+    name: "Go",
+    description: "Go 언어 관용구 및 베스트 프랙티스 리뷰",
+    tags: ["language", "go"],
+    prompt: `Go 베스트 프랙티스 기준으로 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. Go 관용구
+- 에러 핸들링 패턴
+- 명시적 에러 반환
+- defer 활용
+- 빈 인터페이스 최소화
+
+### 2. 네이밍
+- MixedCaps 컨벤션
+- 약어 대문자 (HTTP, URL)
+- 내보내기 (대문자 시작)
+- 패키지 이름
+
+### 3. 동시성
+- goroutine 사용
+- channel 패턴
+- sync 패키지 활용
+- 데이터 레이스 방지
+
+### 4. 인터페이스
+- 작은 인터페이스 선호
+- 암묵적 구현
+- 인터페이스 수용, 구조체 반환
+
+### 5. 에러 처리
+- errors.Is, errors.As
+- 에러 래핑 (%w)
+- 센티널 에러
+- 커스텀 에러 타입
+
+### 6. 테스트
+- 테이블 주도 테스트
+- 서브테스트
+- 테스트 헬퍼`,
+  },
+
+  java: {
+    name: "Java",
+    description: "Java 베스트 프랙티스 및 모던 Java 기능 리뷰",
+    tags: ["language", "java"],
+    prompt: `Java 베스트 프랙티스 기준으로 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 모던 Java (8+)
+- Stream API 활용
+- Optional 사용
+- 람다 표현식
+- 메서드 레퍼런스
+- Record 클래스 (16+)
+
+### 2. 객체 지향
+- SOLID 원칙
+- 상속 vs 컴포지션
+- 인터페이스 기반 설계
+- 불변 객체
+
+### 3. 예외 처리
+- Checked vs Unchecked
+- try-with-resources
+- 예외 체이닝
+- 커스텀 예외
+
+### 4. 컬렉션
+- 적절한 컬렉션 선택
+- 불변 컬렉션 (List.of)
+- 스트림 vs 루프
+- Null 안전 컬렉션
+
+### 5. 동시성
+- ExecutorService
+- CompletableFuture
+- 동기화 전략
+- 불변성 활용
+
+### 6. 메모리
+- 메모리 누수 방지
+- WeakReference
+- 객체 풀링`,
+  },
+
+  rust: {
+    name: "Rust",
+    description: "Rust 소유권, 안전성 관점 리뷰",
+    tags: ["language", "rust"],
+    prompt: `Rust 베스트 프랙티스 기준으로 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 소유권
+- 소유권 이동 vs 빌림
+- 라이프타임 적절성
+- 복사 vs 클론 선택
+
+### 2. 에러 처리
+- Result, Option 활용
+- ? 연산자
+- 커스텀 에러 타입
+- thiserror/anyhow 활용
+
+### 3. 패턴
+- match 완전성
+- if let, while let
+- 구조체 패턴
+
+### 4. 타입 시스템
+- 제네릭 활용
+- 트레이트 바운드
+- Associated Types
+- PhantomData
+
+### 5. 동시성
+- Send, Sync 트레이트
+- Arc, Mutex 활용
+- 채널 통신
+- async/await
+
+### 6. 성능
+- 제로 코스트 추상화
+- 인라이닝
+- 스택 vs 힙 할당`,
+  },
+};
+
+/**
+ * AI/ML Presets
+ * AI/ML 및 챗봇 관련 프리셋
+ */
+export const AI_PRESETS: PresetRegistry = {
+  chatbot: {
+    name: "챗봇/대화형 AI",
+    description: "챗봇 및 대화형 AI 시스템 관점 리뷰",
+    tags: ["ai", "chatbot", "conversational"],
+    prompt: `챗봇/대화형 AI 시스템 관점에서 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 대화 관리
+- 대화 컨텍스트 유지
+- 세션 관리
+- 대화 히스토리 저장
+- 컨텍스트 윈도우 관리
+- 멀티턴 대화 처리
+
+### 2. 프롬프트 엔지니어링
+- 시스템 프롬프트 설계
+- 프롬프트 템플릿 관리
+- 동적 프롬프트 생성
+- Few-shot 예제 관리
+- 프롬프트 인젝션 방지
+
+### 3. LLM 통합
+- API 호출 최적화
+- 토큰 사용량 관리
+- 스트리밍 응답 처리
+- 폴백 모델 전략
+- Rate Limiting 처리
+
+### 4. 응답 처리
+- 응답 파싱 및 검증
+- 할루시네이션 감지
+- 응답 필터링 (부적절한 내용)
+- 구조화된 출력 처리
+
+### 5. RAG (Retrieval Augmented Generation)
+- 문서 청킹 전략
+- 임베딩 생성
+- 벡터 검색 최적화
+- 컨텍스트 주입
+
+### 6. 사용자 경험
+- 타이핑 인디케이터
+- 에러 메시지 친화성
+- 대화 재시작/초기화
+- 피드백 수집
+
+### 7. 안전성
+- 콘텐츠 필터링
+- PII 마스킹
+- 프롬프트 인젝션 방어
+- 출력 검증`,
+  },
+
+  llmIntegration: {
+    name: "LLM API 통합",
+    description: "OpenAI, Anthropic, Google AI 등 LLM API 통합 관점 리뷰",
+    tags: ["ai", "llm", "api"],
+    prompt: `LLM API 통합 관점에서 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. API 클라이언트
+- 공식 SDK 사용 여부
+- 클라이언트 초기화
+- 설정 관리
+- 타임아웃 설정
+
+### 2. 요청 처리
+- 토큰 카운팅
+- 요청 크기 최적화
+- 배치 처리
+- 비동기 요청 관리
+
+### 3. 응답 처리
+- 스트리밍 처리
+- 응답 파싱
+- 에러 코드 처리
+- 재시도 로직
+
+### 4. 비용 관리
+- 토큰 사용량 추적
+- 모델 선택 최적화
+- 캐싱 전략
+- 비용 알림
+
+### 5. 에러 핸들링
+- Rate Limit 처리
+- 네트워크 에러
+- 컨텍스트 길이 초과
+- 콘텐츠 필터 에러
+
+### 6. 보안
+- API 키 관리
+- 요청 로깅 (민감정보 제외)
+- 사용자 데이터 처리`,
+  },
+
+  rag: {
+    name: "RAG 시스템",
+    description: "Retrieval Augmented Generation 시스템 관점 리뷰",
+    tags: ["ai", "rag", "vector"],
+    prompt: `RAG (Retrieval Augmented Generation) 시스템 관점에서 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 문서 처리
+- 문서 로딩 방식
+- 청킹 전략 (크기, 오버랩)
+- 메타데이터 추출
+- 문서 전처리
+
+### 2. 임베딩
+- 임베딩 모델 선택
+- 배치 임베딩 처리
+- 임베딩 캐싱
+- 차원 최적화
+
+### 3. 벡터 저장소
+- 벡터 DB 선택 (Pinecone, Weaviate, Chroma 등)
+- 인덱스 전략
+- 메타데이터 필터링
+- 하이브리드 검색
+
+### 4. 검색
+- 유사도 검색 알고리즘
+- Top-K 선택
+- 리랭킹 전략
+- 검색 품질 평가
+
+### 5. 컨텍스트 조합
+- 검색 결과 병합
+- 컨텍스트 압축
+- 소스 인용
+- 중복 제거
+
+### 6. 응답 생성
+- 프롬프트 구성
+- 소스 기반 응답 강제
+- 할루시네이션 방지
+- 응답 검증`,
+  },
+
+  aiAgent: {
+    name: "AI 에이전트",
+    description: "자율적 AI 에이전트 시스템 관점 리뷰",
+    tags: ["ai", "agent", "autonomous"],
+    prompt: `AI 에이전트 시스템 관점에서 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 에이전트 아키텍처
+- 계획-실행-관찰 루프
+- 상태 관리
+- 메모리 시스템
+- 목표 분해
+
+### 2. 도구 사용
+- 도구 정의 및 스키마
+- 도구 선택 로직
+- 도구 실행 결과 처리
+- 도구 에러 핸들링
+
+### 3. 의사결정
+- 추론 체인
+- 자기 반성 메커니즘
+- 불확실성 처리
+- 휴먼 인 더 루프
+
+### 4. 안전성
+- 액션 검증
+- 샌드박스 실행
+- 권한 제한
+- 무한 루프 방지
+
+### 5. 관찰 가능성
+- 추론 과정 로깅
+- 디버깅 지원
+- 실행 추적
+- 성능 모니터링
+
+### 6. 멀티 에이전트
+- 에이전트 간 통신
+- 역할 분담
+- 협업 패턴
+- 충돌 해결`,
+  },
+
+  mlOps: {
+    name: "MLOps",
+    description: "ML 모델 배포 및 운영 관점 리뷰",
+    tags: ["ai", "mlops", "deployment"],
+    prompt: `MLOps 관점에서 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 모델 관리
+- 모델 버저닝
+- 모델 레지스트리
+- 아티팩트 저장
+- 메타데이터 추적
+
+### 2. 실험 추적
+- 하이퍼파라미터 로깅
+- 메트릭 기록
+- 실험 비교
+- 재현성
+
+### 3. 파이프라인
+- 데이터 파이프라인
+- 학습 파이프라인
+- 평가 파이프라인
+- 배포 파이프라인
+
+### 4. 서빙
+- 모델 서빙 방식
+- 배치 vs 실시간
+- A/B 테스트
+- 카나리 배포
+
+### 5. 모니터링
+- 모델 성능 모니터링
+- 데이터 드리프트 감지
+- 예측 분포 추적
+- 알림 설정
+
+### 6. 거버넌스
+- 모델 문서화
+- 감사 추적
+- 편향 모니터링
+- 규정 준수`,
+  },
+
+  promptEngineering: {
+    name: "프롬프트 엔지니어링",
+    description: "프롬프트 설계 및 최적화 관점 리뷰",
+    tags: ["ai", "prompt", "engineering"],
+    prompt: `프롬프트 엔지니어링 관점에서 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 프롬프트 구조
+- 시스템/사용자/어시스턴트 역할 분리
+- 명확한 지시사항
+- 형식 지정
+- 제약 조건 명시
+
+### 2. 프롬프트 템플릿
+- 변수 치환 방식
+- 조건부 섹션
+- 템플릿 재사용성
+- 버저닝
+
+### 3. 기법 적용
+- Few-shot 예제 품질
+- Chain-of-Thought 유도
+- 역할 부여
+- 출력 형식 지정
+
+### 4. 프롬프트 관리
+- 프롬프트 저장/로드
+- A/B 테스트 지원
+- 프롬프트 히스토리
+- 성능 추적
+
+### 5. 최적화
+- 토큰 효율성
+- 불필요한 텍스트 제거
+- 압축 기법
+- 캐싱
+
+### 6. 안전성
+- 프롬프트 인젝션 방어
+- 탈옥 방지
+- 출력 검증
+- 민감 정보 필터링`,
+  },
+
+  vectorDB: {
+    name: "벡터 데이터베이스",
+    description: "벡터 DB 활용 및 최적화 관점 리뷰",
+    tags: ["ai", "vector", "database"],
+    prompt: `벡터 데이터베이스 활용 관점에서 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 인덱스 설계
+- 인덱스 타입 선택 (HNSW, IVF 등)
+- 파라미터 튜닝
+- 메모리 vs 정확도 트레이드오프
+
+### 2. 데이터 모델링
+- 벡터 차원 최적화
+- 메타데이터 스키마
+- 네임스페이스/컬렉션 구조
+
+### 3. 쿼리 최적화
+- 필터링 전략
+- Top-K 설정
+- 하이브리드 검색 (벡터 + 키워드)
+
+### 4. 데이터 관리
+- 배치 업서트
+- 삭제 전략
+- 백업/복구
+- 동기화
+
+### 5. 성능
+- 쿼리 지연 시간
+- 처리량 최적화
+- 커넥션 풀링
+- 캐싱 전략
+
+### 6. 운영
+- 모니터링 메트릭
+- 스케일링 전략
+- 비용 최적화`,
+  },
+
+  langchain: {
+    name: "LangChain",
+    description: "LangChain 프레임워크 베스트 프랙티스 리뷰",
+    tags: ["ai", "langchain", "framework"],
+    prompt: `LangChain 베스트 프랙티스 기준으로 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 체인 설계
+- LCEL (LangChain Expression Language) 활용
+- 체인 조합 패턴
+- Runnable 인터페이스 활용
+
+### 2. 프롬프트
+- PromptTemplate 사용
+- ChatPromptTemplate 구조
+- 동적 프롬프트 생성
+
+### 3. 메모리
+- 적절한 메모리 타입 선택
+- 메모리 크기 관리
+- 커스텀 메모리 구현
+
+### 4. 에이전트
+- 도구 정의
+- 에이전트 타입 선택
+- 에이전트 실행기 설정
+
+### 5. 검색
+- 문서 로더 활용
+- 텍스트 스플리터 설정
+- 리트리버 구성
+
+### 6. 콜백
+- 콜백 핸들러 구현
+- 스트리밍 처리
+- 로깅/추적`,
+  },
+};
+
+/**
+ * Quality Presets
+ * 코드 품질 관련 프리셋
+ */
+export const QUALITY_PRESETS: PresetRegistry = {
+  cleanCode: {
+    name: "클린 코드",
+    description: "클린 코드 원칙 기반 리뷰",
+    tags: ["quality", "clean-code"],
+    prompt: `클린 코드 원칙에 따라 코드를 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 의미 있는 이름
+- 의도를 나타내는 이름
+- 발음 가능한 이름
+- 검색 가능한 이름
+- 클래스/메서드 네이밍 규칙
+
+### 2. 함수
+- 작게 만들기 (20줄 이하)
+- 한 가지만 하기
+- 추상화 수준 일관성
+- 부수 효과 없애기
+
+### 3. 주석
+- 코드로 의도 표현
+- 불필요한 주석 제거
+- TODO, FIXME 정리
+
+### 4. 형식 맞추기
+- 적절한 줄 길이
+- 세로 밀집도
+- 가로 공백
+
+### 5. 객체와 자료 구조
+- 자료 추상화
+- 디미터 법칙
+- DTO 분리
+
+### 6. 오류 처리
+- 예외 사용
+- 미확인 예외 사용
+- 예외에 의미 담기
+
+### 7. 경계
+- 외부 코드 깔끔하게 사용
+- 어댑터 패턴 활용`,
+  },
+
+  refactoring: {
+    name: "리팩토링 기회",
+    description: "리팩토링이 필요한 코드 스멜 식별",
+    tags: ["quality", "refactoring"],
+    prompt: `리팩토링 관점에서 코드 스멜을 식별해주세요:
+
+## 코드 스멜 체크리스트
+
+### 1. 블로터 (Bloaters)
+- 긴 메서드
+- 큰 클래스
+- 기본 타입 집착
+- 긴 매개변수 목록
+- 데이터 덩어리
+
+### 2. 객체 지향 남용 (OO Abusers)
+- Switch 문
+- 임시 필드
+- 거부된 유산
+- 다른 인터페이스를 가진 대안 클래스
+
+### 3. 변경 방해꾼 (Change Preventers)
+- 산탄총 수술
+- 평행 상속 계층
+- 발산적 변경
+
+### 4. 생략 가능 요소 (Dispensables)
+- 중복 코드
+- 게으른 클래스
+- 데이터 클래스
+- 죽은 코드
+- 추측 일반성
+
+### 5. 결합 (Couplers)
+- 기능 선망
+- 부적절한 친밀
+- 메시지 체인
+- 중재자
+- 불완전한 라이브러리 클래스
+
+## 리팩토링 제안
+각 스멜에 대해 구체적인 리팩토링 기법을 제안해주세요.`,
+  },
+
+  documentation: {
+    name: "문서화",
+    description: "코드 문서화 및 주석 관점 리뷰",
+    tags: ["quality", "documentation"],
+    prompt: `코드 문서화 관점에서 리뷰해주세요:
+
+## 검토 항목
+
+### 1. API 문서화
+- 공개 API 문서 존재
+- 파라미터 설명
+- 반환값 설명
+- 예외/에러 설명
+- 사용 예제
+
+### 2. 코드 주석
+- 복잡한 로직 설명
+- 비즈니스 규칙 명시
+- 왜(Why) 설명 (What 아님)
+- 경고/주의사항
+
+### 3. README
+- 프로젝트 개요
+- 설치 방법
+- 사용법
+- 설정 설명
+
+### 4. 인라인 문서
+- JSDoc/TSDoc/Docstring
+- 타입 설명
+- deprecated 표시
+- see also 참조
+
+### 5. 아키텍처 문서
+- 시스템 구조 설명
+- 의사결정 기록 (ADR)
+- 다이어그램`,
+  },
+
+  maintainability: {
+    name: "유지보수성",
+    description: "장기적 유지보수 관점 리뷰",
+    tags: ["quality", "maintainability"],
+    prompt: `코드 유지보수성 관점에서 리뷰해주세요:
+
+## 검토 항목
+
+### 1. 가독성
+- 코드 자체 문서화
+- 일관된 스타일
+- 적절한 추상화 수준
+- 명확한 제어 흐름
+
+### 2. 모듈성
+- 단일 책임
+- 낮은 결합도
+- 높은 응집도
+- 명확한 인터페이스
+
+### 3. 테스트 가능성
+- 의존성 주입
+- 순수 함수
+- 부수 효과 격리
+- 모킹 용이성
+
+### 4. 확장성
+- 열린-닫힌 원칙
+- 플러그인 구조
+- 설정 외부화
+
+### 5. 디버깅 용이성
+- 명확한 에러 메시지
+- 충분한 로깅
+- 스택 트레이스 보존
+
+### 6. 기술 부채
+- 임시 해결책 식별
+- TODO 항목 정리
+- 레거시 코드 표시`,
+  },
+};
+
+/**
+ * All presets combined
+ */
+export const ALL_PRESETS: PresetRegistry = {
+  ...EXPERIENCE_PRESETS,
+  ...PERSPECTIVE_PRESETS,
+  ...FRAMEWORK_PRESETS,
+  ...DOMAIN_PRESETS,
+  ...LANGUAGE_PRESETS,
+  ...AI_PRESETS,
+  ...QUALITY_PRESETS,
+};
+
+/**
+ * Get preset by key
+ */
+export function getPreset(key: string): ReviewPreset | undefined {
+  return ALL_PRESETS[key];
+}
+
+/**
+ * Get multiple presets by keys
+ */
+export function getPresets(keys: string[]): ReviewPreset[] {
+  return keys.map((key) => ALL_PRESETS[key]).filter(Boolean);
+}
+
+/**
+ * Search presets by tag
+ */
+export function getPresetsByTag(tag: string): ReviewPreset[] {
+  return Object.values(ALL_PRESETS).filter((preset) =>
+    preset.tags.includes(tag)
+  );
+}
+
+/**
+ * Get all preset keys
+ */
+export function getAllPresetKeys(): string[] {
+  return Object.keys(ALL_PRESETS);
+}
+
+/**
+ * Combine multiple presets into a single prompt
+ */
+export function combinePresets(keys: string[], customPrompt?: string): string {
+  const presets = getPresets(keys);
+
+  if (presets.length === 0 && !customPrompt) {
+    return "";
+  }
+
+  const sections: string[] = [];
+
+  // Add header
+  if (presets.length > 0) {
+    const presetNames = presets.map((p) => p.name).join(", ");
+    sections.push(`# 코드 리뷰 가이드\n\n선택된 프리셋: ${presetNames}\n`);
+  }
+
+  // Add each preset
+  presets.forEach((preset, index) => {
+    sections.push(`---\n\n## ${index + 1}. ${preset.name}\n\n${preset.prompt}`);
+  });
+
+  // Add custom prompt
+  if (customPrompt) {
+    sections.push(`---\n\n## 추가 지시사항\n\n${customPrompt}`);
+  }
+
+  return sections.join("\n\n");
+}
+
+/**
+ * Get preset categories for display
+ */
+export function getPresetCategories(): Array<{
+  category: PresetCategory;
+  name: string;
+  presets: Array<{ key: string; preset: ReviewPreset }>;
+}> {
+  return [
+    {
+      category: "experience",
+      name: "경험 레벨",
+      presets: Object.entries(EXPERIENCE_PRESETS).map(([key, preset]) => ({
+        key,
+        preset,
+      })),
+    },
+    {
+      category: "perspective",
+      name: "리뷰 관점",
+      presets: Object.entries(PERSPECTIVE_PRESETS).map(([key, preset]) => ({
+        key,
+        preset,
+      })),
+    },
+    {
+      category: "framework",
+      name: "프레임워크",
+      presets: Object.entries(FRAMEWORK_PRESETS).map(([key, preset]) => ({
+        key,
+        preset,
+      })),
+    },
+    {
+      category: "domain",
+      name: "도메인",
+      presets: Object.entries(DOMAIN_PRESETS).map(([key, preset]) => ({
+        key,
+        preset,
+      })),
+    },
+    {
+      category: "language",
+      name: "프로그래밍 언어",
+      presets: Object.entries(LANGUAGE_PRESETS).map(([key, preset]) => ({
+        key,
+        preset,
+      })),
+    },
+    {
+      category: "ai",
+      name: "AI/ML",
+      presets: Object.entries(AI_PRESETS).map(([key, preset]) => ({
+        key,
+        preset,
+      })),
+    },
+    {
+      category: "quality",
+      name: "코드 품질",
+      presets: Object.entries(QUALITY_PRESETS).map(([key, preset]) => ({
+        key,
+        preset,
+      })),
+    },
+  ];
+}