@blastlabs/utils 1.14.0 → 1.15.1

package/.cursor/rules/documentation.mdc

@@ -0,0 +1,22 @@
+---
+description: 문서화 가이드라인
+globs: 
+alwaysApply: false
+---
+
+# Documentation Guidelines
+
+## JSDoc
+
+- 모든 public API에 JSDoc 주석 사용
+- 예제 코드 포함
+- edge cases와 gotchas 문서화
+
+## 문서 업데이트
+
+- 기능 추가 시 README.md 업데이트
+- 새 hooks 추가 시 관련 docs/*.md 업데이트
+
+## 필수 사항
+
+- **Always** update documentation when adding features

package/.cursor/rules/entities-layer.mdc

@@ -0,0 +1,66 @@
+---
+description: "Entities 레이어 구조 및 API 패턴"
+globs: ["**/entities/**"]
+---
+
+# Entities Layer (엔티티)
+
+엔티티는 도메인 모델과 API 로직을 관리합니다.
+
+## 구조
+```
+entities/
+└── (엔티티 이름)/          예: inquiry, popular-product
+    ├── api/
+    │   ├── mapper/
+    │   │   ├── map-(엔티티 이름).ts
+    │   │   └── map-(엔티티 이름)-detail.ts
+    │   ├── query/
+    │   │   ├── (엔티티 이름)-list-query.ts
+    │   │   └── (엔티티 이름)-detail-query.ts
+    │   ├── get-(엔티티 이름)-list.ts
+    │   ├── get-(엔티티 이름)-detail.ts
+    │   ├── (엔티티 이름)-queries.ts
+    │   ├── mutate.ts
+    │   ├── query.ts
+    │   └── index.ts
+    ├── model/
+    │   ├── (엔티티 이름).ts
+    │   ├── (엔티티 이름)-detail.ts
+    │   └── (엔티티 이름)-update.ts
+    ├── schema.ts
+    └── index.ts
+```
+
+## 각 파일의 역할
+- **mapper/**: API 응답을 도메인 모델로 변환
+- **query/**: 쿼리 파라미터 타입 정의
+- **get-*-list.ts**: 리스트 조회 API 함수
+- **get-*-detail.ts**: 상세 조회 API 함수
+- **\*-queries.ts**: TanStack Query queryOptions 정의 (all, lists, list, details, detail 등)
+- **mutate.ts**: mutation 함수들
+- **model/**: 도메인 모델 타입 정의
+- **schema.ts**: zod 스키마 정의 및 변환 함수
+- **index.ts**: `export * as (엔티티 이름)Api from "./api"`
+
+## 예시
+```
+entities/inquiry/
+├── api/
+│   ├── mapper/
+│   │   ├── map-inquiry.ts
+│   │   └── map-inquiry-detail.ts
+│   ├── query/
+│   │   ├── inquiry-list-query.ts
+│   │   └── inquiry-detail-query.ts
+│   ├── get-inquiry-list.ts
+│   ├── get-inquiry-detail.ts
+│   └── inquiry-queries.ts
+├── model/
+│   ├── inquiry.ts
+│   └── inquiry-detail.ts
+└── schema.ts
+```
+
+## TanStack Query 패턴
+서버 상태 관리는 TanStack Query의 queryOptions 패턴을 사용합니다.

package/.cursor/rules/fsd-architecture.mdc

@@ -0,0 +1,32 @@
+---
+description: "Feature-Sliced Design 아키텍처 가이드"
+alwaysApply: true
+---
+
+# Feature-Sliced Design (FSD) 아키텍처
+
+프로젝트는 [FSD 공식문서](https://feature-sliced.github.io/documentation/kr/docs/get-started/overview)를 참고하여 구조화되어 있습니다.
+
+## apps 내 폴더 구조
+```
+src/
+├── app/            # 앱 초기화, 프로바이더, 라우팅
+├── entities/       # 도메인 모델, API
+├── feature/        # 비즈니스 기능
+├── shared/         # 공통 유틸, UI
+├── views/          # 페이지 컴포넌트
+└── widget/         # 독립적 UI 블록
+```
+
+## 레이어 의존성 규칙
+- `views` → `widget`, `feature`, `entities`, `shared`
+- `widget` → `feature`, `entities`, `shared`
+- `feature` → `entities`, `shared`
+- `entities` → `shared`
+- `shared` → 외부 라이브러리만
+
+## 개발 가이드라인
+1. **FSD 아키텍처 준수**: 레이어 구조를 유지합니다
+2. **명명 규칙**: 파일명과 폴더명은 케밥 케이스 사용
+3. **타입 안정성**: TypeScript로 타입을 명확하게 정의
+4. **코드 재사용**: 공통 로직은 shared, 도메인 로직은 entities에 배치

package/.cursor/rules/git-commit.mdc

@@ -0,0 +1,30 @@
+---
+description: Git 커밋 컨벤션
+globs: 
+alwaysApply: false
+---
+
+# Git Commit Convention
+
+## Conventional Commits Format
+
+- `feat(scope): description` - New features
+- `fix(scope): description` - Bug fixes
+- `refactor(scope): description` - Code refactoring
+- `docs(scope): description` - Documentation changes
+- `test(scope): description` - Test changes
+- `chore(scope): description` - Build/tooling changes
+
+## 예시
+
+- `feat(hooks): add useAuth hook for authentication management`
+- `fix(hooks): resolve SSR localStorage error in useAuth`
+- `docs(auth): update useAuth documentation with examples`
+
+## 커밋 전 체크리스트
+
+1. Run tests: `npm test`
+2. Build successfully: `npm run build`
+3. Update documentation if needed
+4. Follow conventional commit format
+5. Add Co-Authored-By line for AI assistance

package/.cursor/rules/project-overview.mdc

@@ -0,0 +1,44 @@
+---
+description: @blastlabs/utils 프로젝트 개요 및 기본 가이드라인
+globs: 
+alwaysApply: true
+---
+
+# @blastlabs/utils Development Rules
+
+React 애플리케이션을 위한 종합 TypeScript 유틸리티 라이브러리입니다.
+
+## 제공 기능
+
+- Authentication management (useAuth, AuthGuard)
+- UI/UX hooks (useTabs, useMediaQuery, useWindowSize)
+- Form management (useCRUDForm)
+- Time utilities (useCountdown, useStopwatch, useInterval)
+- Storage hooks (useLocalStorage, useSessionStorage, useCopyToClipboard)
+- State management hooks (useToggle, usePrevious)
+- Performance hooks (useDebounce, useThrottle, useIntersectionObserver)
+- Event hooks (useEventListener, useClickOutside)
+
+## 문서
+
+- [Development Guide](docs/development-guide.md) - 개발 가이드 통합 문서
+- [Authentication Hooks](docs/auth-hooks.md) - useAuth, AuthGuard
+- [UI Hooks](docs/ui-hooks.md) - useTabs, useMediaQuery, useWindowSize
+
+## 파일 구조
+
+```
+src/
+├── hooks/
+│   ├── auth/           # Authentication hooks
+│   ├── ui/             # UI/UX hooks
+│   ├── time/           # Time-related hooks
+│   ├── form/           # Form management hooks
+│   ├── storage/        # Storage hooks
+│   ├── state/          # State management hooks
+│   ├── performance/    # Performance hooks
+│   └── event/          # Event hooks
+└── components/
+    ├── auth/           # Auth components (AuthGuard)
+    └── dev/            # Development components
+```

package/.cursor/rules/react-hooks.mdc

@@ -0,0 +1,43 @@
+---
+description: React Hooks 개발 규칙 및 SSR 안전성
+globs: "**/use*.ts,**/use*.tsx"
+alwaysApply: false
+---
+
+# React Hooks Rules
+
+## 필수 규칙
+
+- 모든 hooks는 SSR-safe 해야 함 (browser APIs 접근 시 `typeof window !== 'undefined'` 체크)
+- `useCallback`, `useMemo`를 적절히 사용하여 성능 최적화
+- `useEffect`에서 side effects 정리 필수
+- React Hooks 규칙 준수 (조건부 호출 금지 등)
+
+## SSR-Safe Hook Pattern
+
+```typescript
+const [value, setValue] = useState(() => {
+  if (typeof window === 'undefined') return defaultValue;
+  return window.localStorage.getItem(key);
+});
+
+useEffect(() => {
+  if (typeof window === 'undefined') return;
+  // Browser-only code
+}, []);
+```
+
+## Storage Pattern
+
+```typescript
+const setItem = useCallback((value: T) => {
+  if (typeof window === 'undefined') return;
+
+  const storage = rememberMe ? localStorage : sessionStorage;
+  storage.setItem(key, JSON.stringify(value));
+}, [key, rememberMe]);
+```
+
+## 중요
+
+- **Always** check SSR compatibility for browser APIs

package/.cursor/rules/shared-layer.mdc

@@ -0,0 +1,57 @@
+---
+description: "Shared 레이어 구조 및 lib vs utils 구분"
+globs: ["**/shared/**"]
+---
+
+# Shared Layer (공유 레이어)
+
+프로젝트 전체에서 공유되는 코드를 관리합니다.
+
+## 구조
+```
+shared/
+├── api/                    API 인스턴스 설정 (instance_v2.ts 등)
+├── constant/               공통 상수 (path.ts 등)
+├── hooks/                  공통 React 훅
+├── mock-data/              개발용 목 데이터
+├── lib/                    라이브러리 래퍼 및 설정
+│   └── (라이브러리명)/
+│       ├── provider.tsx    라이브러리 Provider 래퍼
+│       └── config.ts       라이브러리 기본 설정
+├── ui/
+│   ├── component/          재사용 가능한 UI 컴포넌트
+│   │   └── (컴포넌트명)/
+│   │       ├── index.tsx
+│   │       ├── types.ts
+│   │       ├── styles.ts
+│   │       └── (컴포넌트명).tsx
+│   ├── theme/              테마 관련 CSS 파일
+│   └── utils/              UI 관련 유틸리티 함수
+├── util/                   일반 유틸리티 함수
+└── utils/                  추가 유틸리티 함수
+```
+
+## lib vs utils 구분 기준
+
+### `shared/lib/`
+외부 라이브러리를 프로젝트에 맞게 감싸거나 설정하는 코드
+- 라이브러리 래퍼(wrapper) 컴포넌트
+- 라이브러리 초기 설정 및 Provider
+- 예시:
+  - `shared/lib/react-hook-form/form-provider.tsx`
+  - `shared/lib/tanstack-query/query-client.tsx`
+  - `shared/lib/suspense/suspense-wrapper.tsx`
+
+### `shared/utils/` (또는 `shared/util/`)
+순수 유틸리티 함수 및 비즈니스 로직 헬퍼
+- 라이브러리와 무관한 순수 함수
+- 라이브러리 기능을 사용하는 유틸 함수
+- 예시:
+  - `shared/util/convert-price.ts` - 가격 변환 함수
+  - `shared/util/export-excel.ts` - 엑셀 내보내기 함수
+  - `shared/util/form-validation.ts` - 폼 검증 유틸
+
+## 판단 기준
+- 라이브러리를 감싸는가? → `lib/`
+- 라이브러리와 무관한 로직인가? → `utils/`
+- 라이브러리 기능을 사용하는 유틸인가? → `utils/`

package/.cursor/rules/testing.mdc

@@ -0,0 +1,29 @@
+---
+description: 테스트 작성 가이드라인
+globs: "**/*.test.ts,**/*.test.tsx,**/__tests__/**"
+alwaysApply: false
+---
+
+# Testing Guidelines
+
+## 테스트 도구
+
+- Vitest 사용
+- @testing-library/react 사용
+
+## 테스트 원칙
+
+- 모든 hooks에 대해 포괄적인 테스트 작성
+- SSR 시나리오 테스트 포함
+- 높은 테스트 커버리지 목표
+
+## 테스트 실행
+
+```bash
+npm test
+```
+
+## 필수 사항
+
+- **Always** write tests for new features
+- 새 기능 추가 시 반드시 테스트 포함

package/.cursor/rules/typescript-standards.mdc

@@ -0,0 +1,36 @@
+---
+description: TypeScript 코딩 표준 및 타입 규칙
+globs: "**/*.ts,**/*.tsx"
+alwaysApply: false
+---
+
+# TypeScript Standards
+
+## 타입 규칙
+
+- strict type checking 사용
+- `any` 타입 대신 명시적 타입 사용
+- public types와 interfaces는 모두 export
+- 재사용 가능한 컴포넌트에는 generics 사용
+
+## 예시
+
+### Hook Return Pattern
+
+```typescript
+export interface UseHookReturn {
+  // State
+  value: T;
+  isLoading: boolean;
+  error: Error | null;
+
+  // Actions
+  action: () => void;
+  reset: () => void;
+}
+```
+
+## 금지 사항
+
+- **Never** use `any` type without justification
+- **Always** provide TypeScript types for public APIs

package/.cursor/rules/views-layer.mdc

@@ -0,0 +1,71 @@
+---
+description: "Views 레이어 (페이지) 구조"
+globs: ["**/views/**"]
+---
+
+# Views Layer (페이지 레이어)
+
+페이지 단위의 UI와 로직을 관리합니다.
+
+## 구조
+```
+views/
+└── (페이지명)/             예: inquiry, product, seller
+    ├── page.tsx            메인 페이지 컴포넌트 (필수)
+    ├── (페이지명)-list-page.tsx
+    ├── (페이지명)-detail-page.tsx
+    ├── detail/
+    │   ├── page.tsx
+    │   ├── ui/
+    │   ├── hooks/          use-(페이지명)-detail-data.tsx 등
+    │   └── components/
+    ├── list/
+    │   ├── (컬럼명)-column.tsx
+    │   ├── search.tsx
+    │   └── (모달명)-modal.tsx
+    ├── ui/
+    ├── hooks/              use-(페이지명)-data.tsx, use-(페이지명)-actions.tsx 등
+    ├── components/
+    ├── utils/
+    ├── schema/             zod 스키마
+    └── constants.ts
+```
+
+## 예시
+
+### 기본 페이지 구조
+```
+views/inquiry/
+├── detail/
+│   └── page.tsx
+├── inquiry-list-page.tsx
+└── list/
+    ├── inquiry-column.tsx
+    ├── inquiry-modal.tsx
+    └── search.tsx
+```
+
+### 상세 페이지 구조
+```
+views/ai-management/agency/agency-detail/
+├── page.tsx
+├── hooks/
+│   ├── use-agency-detail-data.tsx
+│   └── use-agency-data-actions.tsx
+├── components/
+│   └── agency-basic-info-tab.tsx
+└── schema/
+    └── agency-detail.ts
+```
+
+### 관리 페이지 구조
+```
+views/product/category-management/
+├── page.tsx
+├── hooks/
+│   ├── use-category-data.tsx
+│   └── use-category-actions.tsx
+└── ui/
+    ├── category-management.tsx
+    └── category-modal.tsx
+```

package/bin/init-ai-rules.cjs

@@ -3,53 +3,42 @@
 const fs = require("fs");
 const path = require("path");
 
-const TEMPLATES = {
-  base: "base.md",
-  fsd: "fsd.md",
-  testing: "testing.md",
-  nextjs: "nextjs.md",
-  vite: "vite.md",
-  monorepo: "monorepo.md",
-  project: "project-specific.md",
+// 규칙 카테고리별 정의
+const RULE_CATEGORIES = {
+  // 기본 규칙 (항상 포함)
+  base: [
+    "typescript-standards.mdc",
+    "react-hooks.mdc",
+    "testing.mdc",
+    "documentation.mdc",
+    "git-commit.mdc",
+  ],
+  // FSD 아키텍처 규칙
+  fsd: [
+    "fsd-architecture.mdc",
+    "entities-layer.mdc",
+    "shared-layer.mdc",
+    "views-layer.mdc",
+  ],
 };
 
 function parseArgs(args) {
   const options = {
-    projectName: null,
-    projectDescription: "프로젝트 설명을 작성해주세요.",
-    framework: null,  // 'nextjs' or 'vite'
     fsd: false,
-    testing: false,
-    monorepo: false,
-    packageManager: "pnpm",
+    all: false,
+    list: false,
     help: false,
   };
 
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    
+  for (const arg of args) {
     if (arg === "--help" || arg === "-h") {
       options.help = true;
-    } else if (arg === "--next" || arg === "--nextjs") {
-      options.framework = "nextjs";
-    } else if (arg === "--vite") {
-      options.framework = "vite";
     } else if (arg === "--fsd") {
       options.fsd = true;
-    } else if (arg === "--testing" || arg === "--test") {
-      options.testing = true;
-    } else if (arg === "--monorepo") {
-      options.monorepo = true;
-    } else if (arg === "--npm") {
-      options.packageManager = "npm";
-    } else if (arg === "--yarn") {
-      options.packageManager = "yarn";
-    } else if (arg === "--pnpm") {
-      options.packageManager = "pnpm";
-    } else if (!arg.startsWith("--") && !options.projectName) {
-      options.projectName = arg;
-    } else if (!arg.startsWith("--") && options.projectName && !options.projectDescription) {
-      options.projectDescription = arg;
+    } else if (arg === "--all") {
+      options.all = true;
+    } else if (arg === "--list" || arg === "-l") {
+      options.list = true;
     }
   }
 
@@ -57,111 +46,129 @@ function parseArgs(args) {
 }
 
 function showHelp() {
-  console.log("@blastlabs/utils - AI Rules Generator\n");
-  console.log("프로젝트에 .cursorrules와 CLAUDE.md 파일을 생성합니다.\n");
-  console.log("사용법: npx blastlabs-init-ai-rules <project-name> [options]\n");
+  console.log("@blastlabs/utils - Cursor Rules Installer\n");
+  console.log("프로젝트에 .cursor/rules/ 규칙 파일들을 설치합니다.\n");
+  console.log("사용법: npx blastlabs-init-ai-rules [options]\n");
   console.log("Options:");
-  console.log("  --next, --nextjs    Next.js 프로젝트 규칙 포함");
-  console.log("  --vite              Vite 프로젝트 규칙 포함");
-  console.log("  --fsd               Feature-Sliced Design 규칙 포함");
-  console.log("  --testing, --test   테스트 전략 규칙 포함");
-  console.log("  --monorepo          모노레포 규칙 포함");
-  console.log("  --npm               npm 사용 (기본값: pnpm)");
-  console.log("  --yarn              yarn 사용");
-  console.log("  --pnpm              pnpm 사용 (기본값)");
+  console.log("  --fsd         FSD 아키텍처 규칙 포함");
+  console.log("  --all         모든 규칙 설치 (base + fsd)");
+  console.log("  --list, -l    설치 가능한 규칙 목록 보기");
+  console.log("  --help, -h    도움말 보기");
   console.log("\n예시:");
-  console.log('  npx blastlabs-init-ai-rules "My Project" --vite --fsd');
-  console.log('  npx blastlabs-init-ai-rules "Admin" --next --fsd --testing --monorepo');
-  console.log('  npx blastlabs-init-ai-rules "Web App" "React 웹 애플리케이션" --vite');
+  console.log("  npx blastlabs-init-ai-rules          # 기본 규칙만");
+  console.log("  npx blastlabs-init-ai-rules --fsd    # 기본 + FSD 규칙");
+  console.log("  npx blastlabs-init-ai-rules --all    # 모든 규칙");
   console.log("\n⚠️  프로젝트 루트 디렉토리에서 실행해주세요!");
 }
 
-function loadTemplate(name) {
-  const templatePath = path.join(__dirname, "..", "templates", name);
-  try {
-    return fs.readFileSync(templatePath, "utf-8");
-  } catch (error) {
-    console.error(`❌ 템플릿 파일을 찾을 수 없습니다: ${name}`);
-    return "";
+function showList() {
+  console.log("📋 설치 가능한 규칙 목록\n");
+  
+  console.log("📦 기본 규칙 (base) - 항상 포함:");
+  for (const rule of RULE_CATEGORIES.base) {
+    console.log(`   ├── ${rule}`);
+  }
+  
+  console.log("\n🏗️  FSD 아키텍처 규칙 (--fsd):");
+  for (const rule of RULE_CATEGORIES.fsd) {
+    console.log(`   ├── ${rule}`);
+  }
+  
+  console.log("\n💡 각 규칙은 globs 패턴으로 자동 적용됩니다.");
+}
+
+function getRulesSourceDir() {
+  // 패키지 내 .cursor/rules 경로
+  return path.join(__dirname, "..", ".cursor", "rules");
+}
+
+function copyRule(ruleName, sourceDir, targetDir) {
+  const sourcePath = path.join(sourceDir, ruleName);
+  const targetPath = path.join(targetDir, ruleName);
+
+  if (!fs.existsSync(sourcePath)) {
+    console.log(`   ⚠️  ${ruleName} - 소스 파일 없음, 건너뜀`);
+    return false;
+  }
+
+  if (fs.existsSync(targetPath)) {
+    console.log(`   ⏭️  ${ruleName} - 이미 존재함, 건너뜀`);
+    return false;
   }
+
+  fs.copyFileSync(sourcePath, targetPath);
+  console.log(`   ✅ ${ruleName}`);
+  return true;
 }
 
 function main() {
   const args = process.argv.slice(2);
   const options = parseArgs(args);
 
-  if (options.help || !options.projectName) {
+  if (options.help) {
     showHelp();
     process.exit(0);
   }
 
-  const targetDir = process.cwd();
-
-  // 템플릿 조합
-  let content = loadTemplate(TEMPLATES.base);
-
-  if (options.fsd) {
-    content += "\n" + loadTemplate(TEMPLATES.fsd);
+  if (options.list) {
+    showList();
+    process.exit(0);
   }
 
-  if (options.testing) {
-    content += "\n" + loadTemplate(TEMPLATES.testing);
+  const targetDir = process.cwd();
+  const rulesTargetDir = path.join(targetDir, ".cursor", "rules");
+  const rulesSourceDir = getRulesSourceDir();
+
+  // 소스 디렉토리 확인
+  if (!fs.existsSync(rulesSourceDir)) {
+    console.error("❌ 규칙 소스 디렉토리를 찾을 수 없습니다.");
+    console.error(`   경로: ${rulesSourceDir}`);
+    process.exit(1);
   }
 
-  if (options.framework === "nextjs") {
-    content += "\n" + loadTemplate(TEMPLATES.nextjs);
-  } else if (options.framework === "vite") {
-    content += "\n" + loadTemplate(TEMPLATES.vite);
+  // .cursor/rules 디렉토리 생성
+  if (!fs.existsSync(rulesTargetDir)) {
+    fs.mkdirSync(rulesTargetDir, { recursive: true });
+    console.log("📁 .cursor/rules/ 디렉토리 생성됨\n");
   }
 
-  if (options.monorepo) {
-    content += "\n" + loadTemplate(TEMPLATES.monorepo);
+  // 설치할 규칙 목록 결정
+  let rulesToInstall = [...RULE_CATEGORIES.base];
+
+  if (options.all || options.fsd) {
+    rulesToInstall = [...rulesToInstall, ...RULE_CATEGORIES.fsd];
   }
 
-  // 항상 project-specific 섹션 추가
-  content += "\n" + loadTemplate(TEMPLATES.project);
+  // 중복 제거
+  rulesToInstall = [...new Set(rulesToInstall)];
 
-  // 플레이스홀더 치환
-  const frameworkName = options.framework === "nextjs" ? "Next.js" : 
-                        options.framework === "vite" ? "Vite" : "React";
-  
-  content = content
-    .replace(/\{\{PROJECT_NAME\}\}/g, options.projectName)
-    .replace(/\{\{PROJECT_DESCRIPTION\}\}/g, options.projectDescription)
-    .replace(/\{\{PACKAGE_MANAGER\}\}/g, options.packageManager)
-    .replace(/\{\{FRAMEWORK\}\}/g, frameworkName);
-
-  // .cursorrules 파일 생성
-  const cursorrulesPath = path.join(targetDir, ".cursorrules");
-  if (fs.existsSync(cursorrulesPath)) {
-    console.log("⚠️  .cursorrules 파일이 이미 존재합니다. 덮어쓰기를 건너뜁니다.");
-  } else {
-    fs.writeFileSync(cursorrulesPath, content);
-    console.log("✅ .cursorrules 생성 완료");
-  }
+  console.log("📥 규칙 설치 중...\n");
 
-  // CLAUDE.md 파일 생성 (루트)
-  const claudePath = path.join(targetDir, "CLAUDE.md");
-  if (fs.existsSync(claudePath)) {
-    console.log("⚠️  CLAUDE.md 파일이 이미 존재합니다. 덮어쓰기를 건너뜁니다.");
-  } else {
-    fs.writeFileSync(claudePath, content);
-    console.log("✅ CLAUDE.md 생성 완료");
+  let installedCount = 0;
+  let skippedCount = 0;
+
+  for (const rule of rulesToInstall) {
+    const installed = copyRule(rule, rulesSourceDir, rulesTargetDir);
+    if (installed) {
+      installedCount++;
+    } else {
+      skippedCount++;
+    }
   }
 
-  console.log("\n📁 생성된 파일들:");
-  console.log("├── .cursorrules");
-  console.log("└── CLAUDE.md");
+  console.log("\n" + "─".repeat(40));
+  console.log(`\n✨ 완료! ${installedCount}개 설치, ${skippedCount}개 건너뜀`);
 
-  console.log("\n📦 포함된 규칙:");
-  console.log("├── base (공통 규칙)");
-  if (options.fsd) console.log("├── fsd (Feature-Sliced Design)");
-  if (options.testing) console.log("├── testing (테스트 전략)");
-  if (options.framework) console.log(`├── ${options.framework}`);
-  if (options.monorepo) console.log("├── monorepo");
-  console.log("└── project-specific");
+  console.log("\n📦 설치된 규칙 카테고리:");
+  console.log("   ├── base (기본 규칙)");
+  if (options.all || options.fsd) {
+    console.log("   └── fsd (Feature-Sliced Design)");
+  }
 
-  console.log("\n💡 Tip: 생성된 파일을 프로젝트에 맞게 수정하세요!");
+  console.log("\n💡 Tip:");
+  console.log("   - 각 .mdc 파일의 globs 패턴에 따라 자동 적용됩니다");
+  console.log("   - alwaysApply: true 규칙은 항상 적용됩니다");
+  console.log("   - 프로젝트에 맞게 규칙을 수정하세요!");
 }
 
 main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blastlabs/utils",
-  "version": "1.14.0",
+  "version": "1.15.1",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,7 +11,7 @@
   "files": [
     "dist",
     "bin",
-    "templates"
+    ".cursor/rules"
   ],
   "scripts": {
     "prepare": "npm run build:tsc",

package/templates/base.md

@@ -1,111 +0,0 @@
-# {{PROJECT_NAME}} Development Rules
-
-This file contains development guidelines for AI assistants (Cursor, Claude Code, etc.)
-
-## Project Overview
-
-{{PROJECT_DESCRIPTION}}
-
----
-
-# 프로젝트 기본 정보
-
-- **패키지 매니저**: {{PACKAGE_MANAGER}}
-- **프레임워크**: {{FRAMEWORK}}
-
-## 기술 스택
-
-- TypeScript
-- React
-- TanStack Query
-- Tailwind CSS
-- Zod
-
----
-
-# Common Rules (공통 규칙)
-
-## Code Style & Standards
-
-### TypeScript
-- Use strict type checking (`strict: true` in tsconfig)
-- Prefer explicit types over `any`
-- Export all public types and interfaces
-- Use generics for reusable components
-- Use `type` for unions/intersections, `interface` for object shapes
-
-### Naming Conventions
-- **Files/Folders**: kebab-case (`user-profile.tsx`, `use-auth.ts`)
-- **Components**: PascalCase (`UserProfile`, `AuthGuard`)
-- **Hooks**: camelCase with `use` prefix (`useAuth`, `useLocalStorage`)
-- **Constants**: UPPER_SNAKE_CASE (`API_BASE_URL`, `MAX_RETRY_COUNT`)
-- **Types/Interfaces**: PascalCase (`UserProfile`, `AuthState`)
-
-### Import Order
-1. React/Framework imports
-2. Third-party libraries
-3. Internal modules (absolute paths)
-4. Relative imports
-5. Types (with `type` keyword)
-
-```typescript
-import React, { useState, useEffect } from 'react';
-import { useQuery } from '@tanstack/react-query';
-import { Button } from '@/components/ui';
-import { formatDate } from '../utils';
-import type { User } from '@/types';
-```
-
-## React Best Practices
-
-### Component Patterns
-- Use functional components with hooks
-- Keep components small and focused (single responsibility)
-- Extract reusable logic into custom hooks
-- Use composition over inheritance
-
-### Hooks Rules
-- Only call hooks at the top level
-- Only call hooks from React functions
-- Use `useCallback` for event handlers passed to children
-- Use `useMemo` for expensive calculations
-
-### State Management
-- Keep state as local as possible
-- Lift state up only when necessary
-- Use TanStack Query for server state
-- Use context or Zustand for client global state
-
-## Error Handling
-
-```typescript
-try {
-  const result = await someAsyncOperation();
-  return { data: result, error: null };
-} catch (error) {
-  console.error('Operation failed:', error);
-  return { data: null, error: error instanceof Error ? error : new Error('Unknown error') };
-}
-```
-
-## Git Commit Convention
-
-Use conventional commits format:
-- `feat(scope): description` - New features
-- `fix(scope): description` - Bug fixes
-- `refactor(scope): description` - Code refactoring
-- `docs(scope): description` - Documentation changes
-- `test(scope): description` - Test changes
-- `chore(scope): description` - Build/tooling changes
-
-Examples:
-- `feat(auth): add login functionality`
-- `fix(api): resolve timeout error`
-- `docs(readme): update installation guide`
-
-## Before Committing
-
-1. Run tests: `{{PACKAGE_MANAGER}} test`
-2. Build successfully: `{{PACKAGE_MANAGER}} build`
-3. Lint check: `{{PACKAGE_MANAGER}} lint`
-4. Format code: `{{PACKAGE_MANAGER}} format`

package/templates/fsd.md

@@ -1,150 +0,0 @@
-
----
-
-# Feature-Sliced Design (FSD)
-
-프로젝트는 [FSD 공식문서](https://feature-sliced.github.io/documentation/kr/docs/get-started/overview)를 참고하여 구조화되어 있습니다.
-
-## 폴더 구조
-
-```
-src/
-├── app/          # 앱 설정, providers, 라우팅
-├── entities/     # 도메인 모델, API
-├── features/     # 사용자 기능 단위
-├── shared/       # 공유 컴포넌트, 유틸
-├── views/        # 페이지 컴포넌트
-└── widgets/      # 복합 UI 블록
-```
-
-## Entities Layer (엔티티)
-
-엔티티는 도메인 모델과 API 로직을 관리합니다.
-
-### 구조
-
-```
-entities/
-└── (엔티티 이름)/          예: inquiry, popular-product
-    ├── api/
-    │   ├── mapper/
-    │   │   ├── map-(엔티티 이름).ts
-    │   │   └── map-(엔티티 이름)-detail.ts
-    │   ├── query/
-    │   │   ├── (엔티티 이름)-list-query.ts
-    │   │   └── (엔티티 이름)-detail-query.ts
-    │   ├── get-(엔티티 이름)-list.ts
-    │   ├── get-(엔티티 이름)-detail.ts
-    │   ├── (엔티티 이름)-queries.ts
-    │   ├── mutate.ts
-    │   └── index.ts
-    ├── model/
-    │   ├── (엔티티 이름).ts
-    │   ├── (엔티티 이름)-detail.ts
-    │   └── (엔티티 이름)-update.ts
-    ├── schema.ts
-    └── index.ts
-```
-
-### 각 파일의 역할
-
-- **mapper/**: API 응답을 도메인 모델로 변환
-- **query/**: 쿼리 파라미터 타입 정의
-- **get-\*-list.ts**: 리스트 조회 API 함수
-- **get-\*-detail.ts**: 상세 조회 API 함수
-- **\*-queries.ts**: TanStack Query queryOptions 정의 (all, lists, list, details, detail 등)
-- **mutate.ts**: mutation 함수들
-- **model/**: 도메인 모델 타입 정의
-- **schema.ts**: zod 스키마 정의 및 변환 함수
-- **index.ts**: `export * as (엔티티 이름)Api from "./api"`
-
-### 예시
-
-```
-entities/inquiry/
-├── api/
-│   ├── mapper/
-│   │   ├── map-inquiry.ts
-│   │   └── map-inquiry-detail.ts
-│   ├── query/
-│   │   ├── inquiry-list-query.ts
-│   │   └── inquiry-detail-query.ts
-│   ├── get-inquiry-list.ts
-│   ├── get-inquiry-detail.ts
-│   └── inquiry-queries.ts
-├── model/
-│   ├── inquiry.ts
-│   └── inquiry-detail.ts
-└── schema.ts
-```
-
-## Shared Layer (공유 레이어)
-
-프로젝트 전체에서 공유되는 코드를 관리합니다.
-
-### 구조
-
-```
-shared/
-├── api/                    API 인스턴스 설정
-├── constant/               공통 상수 (path.ts 등)
-├── hooks/                  공통 React 훅
-├── lib/                    라이브러리 래퍼 및 설정
-│   └── (라이브러리명)/
-│       ├── provider.tsx
-│       └── config.ts
-├── ui/
-│   ├── component/          재사용 가능한 UI 컴포넌트
-│   │   └── (컴포넌트명)/
-│   │       ├── index.tsx
-│   │       ├── types.ts
-│   │       └── (컴포넌트명).tsx
-│   ├── theme/              테마 관련 CSS 파일
-│   └── utils/              UI 관련 유틸리티 함수
-└── utils/                  일반 유틸리티 함수
-```
-
-### lib vs utils 구분 기준
-
-#### `shared/lib/`
-외부 라이브러리를 프로젝트에 맞게 감싸거나 설정하는 코드
-- 라이브러리 래퍼(wrapper) 컴포넌트
-- 라이브러리 초기 설정 및 Provider
-- 예시: `react-hook-form/form-provider.tsx`, `tanstack-query/query-client.tsx`
-
-#### `shared/utils/`
-순수 유틸리티 함수 및 비즈니스 로직 헬퍼
-- 라이브러리와 무관한 순수 함수
-- 예시: `convert-price.ts`, `export-excel.ts`, `format-date.ts`
-
-**판단 기준:**
-- 라이브러리를 감싸는가? → `lib/`
-- 순수 함수 또는 유틸인가? → `utils/`
-
-## Views Layer (페이지 레이어)
-
-페이지 단위의 UI와 로직을 관리합니다.
-
-### 구조
-
-```
-views/
-└── (페이지명)/
-    ├── page.tsx                    메인 페이지 컴포넌트 (필수)
-    ├── (페이지명)-list-page.tsx
-    ├── (페이지명)-detail-page.tsx
-    ├── detail/
-    │   ├── page.tsx
-    │   ├── ui/
-    │   ├── hooks/                  use-(페이지명)-detail-data.tsx 등
-    │   └── components/
-    ├── list/
-    │   ├── (컬럼명)-column.tsx
-    │   ├── search.tsx
-    │   └── (모달명)-modal.tsx
-    ├── hooks/
-    ├── components/
-    ├── utils/
-    ├── schema/
-    └── constants.ts
-```

package/templates/monorepo.md

@@ -1,61 +0,0 @@
-
----
-
-# Monorepo Rules
-
-## Structure
-
-```
-root/
-├── apps/
-│   ├── web/            # 웹 앱
-│   ├── admin/          # 어드민
-│   └── mobile/         # 모바일 앱
-├── packages/
-│   ├── ui/             # 공유 UI 컴포넌트
-│   ├── utils/          # 공유 유틸리티
-│   ├── config/         # 공유 설정 (eslint, tsconfig)
-│   └── types/          # 공유 TypeScript 타입
-├── package.json
-└── pnpm-workspace.yaml
-```
-
-## Package Management
-- Use workspace protocol for internal packages (`workspace:*`)
-- Keep shared dependencies in root `package.json`
-- App-specific dependencies in app's `package.json`
-
-```json
-{
-  "dependencies": {
-    "@repo/ui": "workspace:*",
-    "@repo/utils": "workspace:*"
-  }
-}
-```
-
-## Build Order
-- Build packages before apps
-- Use Turborepo for build orchestration
-- Configure proper `dependsOn` in turbo.json
-
-## Shared Configurations
-- Extend base tsconfig in all packages
-- Share ESLint config from `packages/config`
-- Maintain consistent formatting across packages
-
-## Commands
-
-```bash
-# 전체 빌드
-pnpm build
-
-# 특정 앱만 빌드
-pnpm --filter @repo/admin build
-
-# 특정 앱 dev 서버
-pnpm --filter @repo/web dev
-
-# 전체 린트
-pnpm lint
-```

package/templates/nextjs.md

@@ -1,67 +0,0 @@
-
----
-
-# Next.js Rules
-
-## App Router
-- Use Server Components by default
-- Add `'use client'` only when needed (hooks, browser APIs, interactivity)
-- Colocate loading.tsx, error.tsx, not-found.tsx with pages
-- Use route groups `(group)` for organization without affecting URL
-
-## File Structure
-```
-app/
-├── (auth)/
-│   ├── login/page.tsx
-│   └── register/page.tsx
-├── (main)/
-│   ├── dashboard/page.tsx
-│   └── settings/page.tsx
-├── api/
-│   └── [...route]/route.ts
-├── layout.tsx
-└── page.tsx
-```
-
-## Data Fetching
-- Prefer Server Components for data fetching
-- Use `fetch` with caching options in Server Components
-- Use React Query/SWR for client-side data fetching
-- Implement proper loading and error states
-
-## Environment Variables
-- `NEXT_PUBLIC_*` for client-side variables
-- Server-only variables without prefix
-- Use `.env.local` for local development
-
-## SSR Safety
-
-```typescript
-// ❌ Wrong - breaks SSR
-const token = localStorage.getItem('token');
-
-// ✅ Correct - SSR safe
-const token = typeof window !== 'undefined' 
-  ? localStorage.getItem('token') 
-  : null;
-```
-
-## SSR-Safe Hook Pattern
-
-```typescript
-const [value, setValue] = useState(() => {
-  if (typeof window === 'undefined') return defaultValue;
-  return window.localStorage.getItem(key);
-});
-
-useEffect(() => {
-  if (typeof window === 'undefined') return;
-  // Browser-only code
-}, []);
-```
-
-## Image Optimization
-- Always use `next/image` for images
-- Provide width and height or use `fill`
-- Use appropriate `sizes` prop for responsive images

package/templates/project-specific.md

@@ -1,21 +0,0 @@
-
----
-
-# Project Specific Rules (프로젝트별 추가 규칙)
-
-<!-- 여기에 프로젝트 고유의 규칙을 추가하세요 -->
-
-## Custom Rules
-- Add your project-specific rules here
-- Document any exceptions to common rules
-- Include team agreements and decisions
-
-## API Conventions
-- Document API patterns used in this project
-- Specify error handling strategies
-- Define response/request formats
-
-## State Management
-- Document which state library is used
-- Define when to use local vs global state
-- Specify state structure conventions

package/templates/testing.md

@@ -1,66 +0,0 @@
-
----
-
-# 테스트 전략
-
-## 테스트 작성 원칙
-
-### 컴포넌트 (Component) - 단위 테스트
-
-- **대상**: `shared/ui/component/`, 재사용 가능한 컴포넌트
-- **목적**: 컴포넌트의 독립적인 동작 검증
-- **방법**:
-  - Props와 사용자 상호작용에 집중
-  - 외부 의존성(API, 라우팅)은 mock 처리
-  - 렌더링, 이벤트 핸들링, 상태 변경 검증
-
-### 페이지 (Page) - 기능 테스트
-
-- **대상**: `views/*/page.tsx` 페이지 컴포넌트
-- **목적**: 사용자 시나리오와 비즈니스 로직 검증
-- **Mock 최소화 원칙**:
-  - 외부 의존성(API 호출, toast)만 mock
-  - 내부 컴포넌트는 실제로 렌더링하여 통합 테스트
-  - `data-testid` 대신 접근성 기반 쿼리 사용
-
-## Testing Library 쿼리 우선순위
-
-**1순위 (가장 권장):**
-- `getByRole` - 접근성 역할 기반 (button, textbox, checkbox 등)
-- `getByLabelText` - label과 연결된 폼 요소
-- `getByPlaceholderText` - placeholder가 있는 입력 필드
-- `getByText` - 텍스트 내용으로 찾기
-- `getByDisplayValue` - 입력 필드의 현재 값
-
-**2순위:**
-- `getByAltText` - 이미지의 alt 텍스트
-- `getByTitle` - title 속성
-
-**3순위 (최후의 수단):**
-- `getByTestId` - `data-testid` (가능한 한 피해야 함)
-
-**예시:**
-```typescript
-// ✅ 좋은 예
-screen.getByRole('button', { name: '저장' });
-screen.getByRole('checkbox');
-screen.getByText('셀러 정보를 찾을 수 없습니다.');
-screen.getByLabelText(/대표자명/);
-
-// ❌ 나쁜 예
-screen.getByTestId('save-button');
-```
-
-## 테스트 파일 위치
-
-- 컴포넌트와 같은 디렉토리에 `*.test.tsx`
-
-## 테스트 구조
-
-```typescript
-describe('ComponentName', () => {
-  it('should render correctly', () => {});
-  it('should handle user interaction', () => {});
-  it('should show error state', () => {});
-});
-```

package/templates/vite.md

@@ -1,53 +0,0 @@
-
----
-
-# Vite + React Rules
-
-## Environment Variables
-- Use `import.meta.env.VITE_*` for environment variables
-- Only `VITE_` prefixed variables are exposed to client
-
-```typescript
-// ✅ Correct
-const apiUrl = import.meta.env.VITE_API_URL;
-
-// ❌ Wrong - won't work
-const secret = import.meta.env.SECRET_KEY;
-```
-
-## File Structure
-```
-src/
-├── assets/         # Static assets
-├── components/     # React components
-├── hooks/          # Custom hooks
-├── pages/          # Page components
-├── routes/         # Routing configuration
-├── services/       # API services
-├── stores/         # State management
-├── utils/          # Utility functions
-└── main.tsx        # Entry point
-```
-
-## Path Aliases
-- Use `@/` alias for `src/` directory
-- Configure in `vite.config.ts` and `tsconfig.json`
-
-```typescript
-// vite.config.ts
-resolve: {
-  alias: {
-    '@': path.resolve(__dirname, './src'),
-  },
-}
-```
-
-## Build Optimization
-- Use dynamic imports for code splitting
-- Lazy load routes and heavy components
-- Analyze bundle size with `rollup-plugin-visualizer`
-
-```typescript
-// Lazy loading example
-const Dashboard = lazy(() => import('./pages/Dashboard'));
-```