jun-claude-code 0.6.3 → 0.6.7

package/dist/update.js

@@ -0,0 +1,433 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeUpdateStatus = computeUpdateStatus;
+exports.updateClaudeFiles = updateClaudeFiles;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const copy_1 = require("./copy");
+const metadata_1 = require("./metadata");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { MultiSelect } = require('enquirer');
+/**
+ * Compute 3-way update status for a file.
+ * Compares base (from metadata), current (on disk), and new (from template).
+ */
+function computeUpdateStatus(file, sourceDir, destDir, metadata) {
+    const sourcePath = path.join(sourceDir, file);
+    const destPath = path.join(destDir, file);
+    const newHash = (0, copy_1.getFileHash)(sourcePath);
+    const baseHash = metadata?.files[file]?.hash ?? null;
+    const currentExists = fs.existsSync(destPath);
+    const currentHash = currentExists ? (0, copy_1.getFileHash)(destPath) : null;
+    // No base metadata for this file
+    if (!baseHash) {
+        if (!currentExists)
+            return 'new-file';
+        if (currentHash === newHash)
+            return 'unchanged';
+        return 'user-modified';
+    }
+    // Base exists but user deleted the file
+    if (!currentExists)
+        return 'new-file';
+    // All three hashes available
+    if (baseHash === currentHash && currentHash === newHash)
+        return 'unchanged';
+    if (baseHash === currentHash)
+        return 'update-available';
+    if (baseHash === newHash)
+        return 'user-modified';
+    return 'conflict';
+}
+/**
+ * Fetch latest version from npm registry
+ */
+async function fetchLatestVersion(packageName) {
+    try {
+        const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`);
+        if (!response.ok)
+            return null;
+        const data = (await response.json());
+        return data.version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Format update status for MultiSelect hint
+ */
+function updateStatusLabel(status) {
+    switch (status) {
+        case 'update-available': return chalk_1.default.green('update');
+        case 'new-file': return chalk_1.default.green('new');
+        case 'user-modified': return chalk_1.default.yellow('customized');
+        case 'conflict': return chalk_1.default.red('conflict');
+        case 'unchanged': return chalk_1.default.gray('unchanged');
+        case 'removed-upstream': return chalk_1.default.gray('removed upstream');
+    }
+}
+/**
+ * Format update status bracket for log output
+ */
+function updateStatusBracket(status) {
+    switch (status) {
+        case 'update-available': return chalk_1.default.green('[update]');
+        case 'new-file': return chalk_1.default.green('[new]');
+        case 'user-modified': return chalk_1.default.yellow('[skip]');
+        case 'conflict': return chalk_1.default.red('[conflict]');
+        case 'unchanged': return chalk_1.default.gray('[unchanged]');
+        case 'removed-upstream': return chalk_1.default.gray('[removed]');
+    }
+}
+/**
+ * Get aggregate update status for a skill directory
+ */
+function getSkillUpdateStatus(skillName, allStatuses) {
+    const skillFiles = allStatuses.filter(f => f.file.startsWith(`skills/${skillName}/`));
+    if (skillFiles.length === 0)
+        return 'unchanged';
+    if (skillFiles.some(f => f.status === 'conflict'))
+        return 'conflict';
+    if (skillFiles.some(f => f.status === 'update-available'))
+        return 'update-available';
+    if (skillFiles.some(f => f.status === 'new-file'))
+        return 'new-file';
+    if (skillFiles.some(f => f.status === 'user-modified'))
+        return 'user-modified';
+    return 'unchanged';
+}
+/**
+ * MultiSelect prompt for update items
+ */
+async function selectUpdateItems(category, items) {
+    if (items.length === 0)
+        return [];
+    const choices = items.map(item => ({
+        name: item.file,
+        message: item.file.startsWith('agents/')
+            ? path.basename(item.file, '.md')
+            : item.file,
+        hint: updateStatusLabel(item.status) +
+            ((item.status === 'user-modified' || item.status === 'conflict')
+                ? ' \u2014 will overwrite your changes' : ''),
+        enabled: item.status === 'update-available' || item.status === 'new-file',
+    }));
+    const prompt = new MultiSelect({
+        name: category,
+        message: `Select ${category} to update`,
+        choices,
+        hint: '(\u2191\u2193 navigate, <space> toggle, <a> select all, <enter> confirm)',
+    });
+    try {
+        return await prompt.run();
+    }
+    catch {
+        console.log(chalk_1.default.yellow('\nUpdate cancelled.'));
+        process.exit(0);
+    }
+}
+/**
+ * MultiSelect prompt for skill sub-files across multiple skills
+ */
+async function selectSkillUpdateFiles(skills) {
+    const choices = [];
+    for (const { skillName, files } of skills) {
+        const actionable = files.filter(f => f.status !== 'unchanged');
+        if (actionable.length === 0)
+            continue;
+        choices.push({ role: 'separator', message: chalk_1.default.cyan(`\u2500\u2500 ${skillName} \u2500\u2500`) });
+        for (const item of actionable) {
+            choices.push({
+                name: item.file,
+                message: `  ${path.basename(item.file)}`,
+                hint: updateStatusLabel(item.status) +
+                    ((item.status === 'user-modified' || item.status === 'conflict')
+                        ? ' \u2014 will overwrite' : ''),
+                enabled: item.status === 'update-available' || item.status === 'new-file',
+            });
+        }
+    }
+    if (choices.filter(c => !c.role).length === 0)
+        return [];
+    const prompt = new MultiSelect({
+        name: 'skill-files',
+        message: 'Select skill files to update',
+        choices,
+        hint: '(\u2191\u2193 navigate, <space> toggle, <a> select all, <enter> confirm)',
+    });
+    try {
+        return await prompt.run();
+    }
+    catch {
+        console.log(chalk_1.default.yellow('\nUpdate cancelled.'));
+        process.exit(0);
+    }
+}
+/**
+ * Update installed templates while preserving user customizations
+ */
+async function updateClaudeFiles(options = {}) {
+    const { dryRun = false, force = false, project = false } = options;
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const currentVersion = require('../package.json').version;
+    const sourceDir = (0, copy_1.getSourceGlobalDir)();
+    const destDir = project ? path.join(process.cwd(), '.claude') : (0, copy_1.getDestClaudeDir)();
+    const targetLabel = project ? 'project' : 'global';
+    // Step 1: Version info
+    const metadata = (0, metadata_1.loadMetadata)(destDir);
+    const latestVersion = await fetchLatestVersion('jun-claude-code');
+    console.log(chalk_1.default.cyan('Version Info:'));
+    console.log(`  Package version: ${chalk_1.default.bold(currentVersion)}`);
+    if (metadata?.version) {
+        console.log(`  Installed version: ${chalk_1.default.bold(metadata.version)}`);
+    }
+    else {
+        console.log(`  Installed version: ${chalk_1.default.gray('(no metadata found)')}`);
+    }
+    if (latestVersion && latestVersion !== currentVersion) {
+        console.log(`  Latest on npm: ${chalk_1.default.bold(latestVersion)}`);
+        console.log(`  ${chalk_1.default.yellow('Tip:')} npm update -g jun-claude-code`);
+    }
+    console.log();
+    // Check source exists
+    if (!fs.existsSync(sourceDir)) {
+        console.error(chalk_1.default.red('Error:'), 'Source templates/global directory not found');
+        process.exit(1);
+    }
+    // Step 2: Collect file lists
+    const allFiles = (0, copy_1.getAllFiles)(sourceDir);
+    const files = allFiles.filter(file => {
+        if (copy_1.EXCLUDE_ALWAYS.includes(file))
+            return false;
+        if (project && copy_1.EXCLUDE_FROM_PROJECT.includes(file))
+            return false;
+        return true;
+    });
+    if (files.length === 0) {
+        console.log(chalk_1.default.yellow('No template files found.'));
+        return;
+    }
+    // Step 3: Compute 3-way status for each file
+    const fileStatuses = files.map(file => ({
+        file,
+        status: computeUpdateStatus(file, sourceDir, destDir, metadata),
+    }));
+    // Check for removed-upstream files (in metadata but not in new template)
+    if (metadata) {
+        for (const file of Object.keys(metadata.files)) {
+            if (!files.includes(file) && !copy_1.EXCLUDE_ALWAYS.includes(file)) {
+                fileStatuses.push({ file, status: 'removed-upstream' });
+            }
+        }
+    }
+    // Group by status
+    const updateAvailable = fileStatuses.filter(f => f.status === 'update-available');
+    const newFiles = fileStatuses.filter(f => f.status === 'new-file');
+    const userModified = fileStatuses.filter(f => f.status === 'user-modified');
+    const conflicts = fileStatuses.filter(f => f.status === 'conflict');
+    const unchanged = fileStatuses.filter(f => f.status === 'unchanged');
+    const removedUpstream = fileStatuses.filter(f => f.status === 'removed-upstream');
+    // Step 4: Show summary
+    const installedVer = metadata?.version ?? '(unknown)';
+    console.log(chalk_1.default.cyan(`Update Summary (${installedVer} \u2192 ${currentVersion}):`));
+    console.log(chalk_1.default.blue('Destination:'), `${destDir} ${chalk_1.default.gray(`(${targetLabel})`)}`);
+    console.log();
+    if (updateAvailable.length > 0) {
+        console.log(chalk_1.default.green(`  Safe to update (${updateAvailable.length}):`));
+        for (const f of updateAvailable) {
+            console.log(`    ${updateStatusBracket(f.status)} ${f.file}`);
+        }
+    }
+    if (newFiles.length > 0) {
+        console.log(chalk_1.default.green(`  New files (${newFiles.length}):`));
+        for (const f of newFiles) {
+            console.log(`    ${updateStatusBracket(f.status)} ${f.file}`);
+        }
+    }
+    if (userModified.length > 0) {
+        console.log(chalk_1.default.yellow(`  User-modified \u2014 preserved (${userModified.length}):`));
+        for (const f of userModified) {
+            console.log(`    ${updateStatusBracket(f.status)} ${f.file} ${chalk_1.default.gray('(customized)')}`);
+        }
+    }
+    if (conflicts.length > 0) {
+        console.log(chalk_1.default.red(`  Conflicts (${conflicts.length}):`));
+        for (const f of conflicts) {
+            console.log(`    ${updateStatusBracket(f.status)} ${f.file}`);
+        }
+    }
+    if (removedUpstream.length > 0) {
+        console.log(chalk_1.default.gray(`  Removed upstream (${removedUpstream.length}):`));
+        for (const f of removedUpstream) {
+            console.log(`    ${updateStatusBracket(f.status)} ${f.file}`);
+        }
+    }
+    if (unchanged.length > 0) {
+        console.log(chalk_1.default.gray(`  Unchanged (${unchanged.length}): ...`));
+    }
+    console.log();
+    // Check if there are actionable files
+    const actionableStatuses = ['update-available', 'new-file', 'user-modified', 'conflict'];
+    const actionableFiles = fileStatuses.filter(f => actionableStatuses.includes(f.status));
+    if (actionableFiles.length === 0) {
+        console.log(chalk_1.default.green('Everything is up to date!'));
+        return;
+    }
+    // Dry run: stop here
+    if (dryRun) {
+        console.log(chalk_1.default.yellow('No files were changed (dry run mode)'));
+        return;
+    }
+    // Step 5: Determine files to copy
+    let filesToCopy;
+    if (force) {
+        filesToCopy = files;
+    }
+    else {
+        filesToCopy = [];
+        // Legacy install warning
+        if (!metadata) {
+            console.log(chalk_1.default.yellow('No installation metadata found. All existing files will be treated as user-modified.'));
+            console.log(chalk_1.default.yellow('Use --force to overwrite all files.'));
+            console.log();
+        }
+        // Others: auto-include update-available and new-file
+        const categorized = (0, copy_1.categorizeFiles)(actionableFiles.map(f => f.file));
+        for (const file of categorized.others) {
+            const info = actionableFiles.find(f => f.file === file);
+            if (info && (info.status === 'update-available' || info.status === 'new-file')) {
+                filesToCopy.push(file);
+            }
+        }
+        // Agents: MultiSelect
+        const agentInfos = actionableFiles.filter(f => f.file.startsWith('agents/'));
+        if (agentInfos.length > 0) {
+            const selected = await selectUpdateItems('Agents', agentInfos);
+            filesToCopy.push(...selected);
+        }
+        // Skills: 2-step MultiSelect
+        const allSkillStatuses = fileStatuses.filter(f => f.file.startsWith('skills/'));
+        const skillDirs = new Set();
+        for (const f of allSkillStatuses) {
+            const parts = f.file.split('/');
+            if (parts.length >= 2 && parts[1])
+                skillDirs.add(parts[1]);
+        }
+        // Step 1: Select skill directories
+        const skillDirItems = [];
+        for (const skillName of Array.from(skillDirs).sort()) {
+            const status = getSkillUpdateStatus(skillName, allSkillStatuses);
+            if (status !== 'unchanged') {
+                skillDirItems.push({ file: skillName, status });
+            }
+        }
+        if (skillDirItems.length > 0) {
+            const selectedSkillDirs = await selectUpdateItems('Skills', skillDirItems);
+            // Step 2: For selected skills, show sub-file selection
+            const singleFileSkills = [];
+            const multiFileSkills = [];
+            for (const skillName of selectedSkillDirs) {
+                const skillFiles = allSkillStatuses.filter(f => f.file.startsWith(`skills/${skillName}/`));
+                const actionableSkillFiles = skillFiles.filter(f => f.status !== 'unchanged');
+                if (actionableSkillFiles.length <= 1) {
+                    // Auto-include single actionable file
+                    singleFileSkills.push(...actionableSkillFiles.map(f => f.file));
+                }
+                else {
+                    multiFileSkills.push({ skillName, files: skillFiles });
+                }
+            }
+            filesToCopy.push(...singleFileSkills);
+            if (multiFileSkills.length > 0) {
+                const selectedSubFiles = await selectSkillUpdateFiles(multiFileSkills);
+                filesToCopy.push(...selectedSubFiles);
+            }
+        }
+    }
+    // Step 6: Copy files
+    let copiedCount = 0;
+    for (const file of filesToCopy) {
+        const sourcePath = path.join(sourceDir, file);
+        const destPath = path.join(destDir, file);
+        const exists = fs.existsSync(destPath);
+        (0, copy_1.copyFile)(sourcePath, destPath);
+        const label = exists ? chalk_1.default.yellow('[overwritten]') : chalk_1.default.green('[created]');
+        console.log(`  ${label} ${file}`);
+        copiedCount++;
+    }
+    // Merge settings.json
+    (0, copy_1.mergeSettingsJson)(sourceDir, destDir, { project });
+    // Update metadata
+    const updatedMeta = (0, metadata_1.mergeMetadata)(metadata, filesToCopy, sourceDir, currentVersion);
+    // Refresh hashes for unchanged files
+    for (const fi of unchanged) {
+        const sourcePath = path.join(sourceDir, fi.file);
+        if (fs.existsSync(sourcePath)) {
+            updatedMeta.files[fi.file] = { hash: (0, copy_1.getFileHash)(sourcePath) };
+        }
+    }
+    (0, metadata_1.saveMetadata)(destDir, updatedMeta);
+    // Step 7: Summary
+    console.log();
+    const newCount = filesToCopy.filter(f => {
+        const info = fileStatuses.find(i => i.file === f);
+        return info?.status === 'new-file';
+    }).length;
+    const updateCount = copiedCount - newCount;
+    const preservedCount = userModified.length + conflicts.length -
+        filesToCopy.filter(f => {
+            const info = fileStatuses.find(i => i.file === f);
+            return info && (info.status === 'user-modified' || info.status === 'conflict');
+        }).length;
+    const parts = [];
+    if (updateCount > 0)
+        parts.push(`updated ${updateCount} files`);
+    if (newCount > 0)
+        parts.push(`added ${newCount} new files`);
+    if (preservedCount > 0)
+        parts.push(`preserved ${preservedCount} customized files`);
+    if (parts.length > 0) {
+        console.log(chalk_1.default.green(`Done! ${parts.join(', ')}.`));
+    }
+    else {
+        console.log(chalk_1.default.green('Done! No files were updated.'));
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jun-claude-code",
-  "version": "0.6.3",
+  "version": "0.6.7",
   "description": "Claude Code configuration template - copy .claude settings to your project",
   "main": "dist/index.js",
   "bin": "dist/cli.js",

package/templates/global/CLAUDE.md

@@ -1,5 +1,9 @@
 # Claude Code 작업 가이드
 
+## Monorepo 주의사항
+
+Monorepo 환경에서는 **반드시 repo root에서 Claude Code CLI를 실행**해야 hooks가 정상 작동합니다. 서브 패키지 디렉토리에서 실행하면 `.claude/` 경로를 찾지 못해 hooks가 무시됩니다.
+
 ## Context 절약 원칙
 
 Main Agent의 Context Window는 제한적입니다. Subagent가 할 수 있는 작업은 Subagent에 위임합니다.
@@ -188,6 +192,34 @@ Plan 파일의 Context 섹션에 위 내용을 명시하여 작업 목적이 희
 
 <checklist>
 
+### Step 3.0: BFF 구현 순서 -- FE/BE/DB가 모두 관련된 기능인 경우
+
+> FE가 필요로 하는 기능을 먼저 정의하고, 그에 맞춰 DB와 API를 설계한다.
+
+구현 순서:
+1. FE 구현 (UI + 인터랙션)
+2. DB 설계 (FE가 필요로 하는 데이터 구조 기반)
+3. Decision Gate: DB 구현 타당성 평가
+4. API 구현 (FE와 DB를 연결)
+
+Decision Gate 판단 기준:
+
+| 판단 항목 | 타당 (진행) | 비타당 (분리 또는 FE 수정) |
+|-----------|------------|--------------------------|
+| DB 구현 난이도 | 기존 스키마 확장 수준 | 대규모 스키마 변경, 마이그레이션 리스크 |
+| 유지보수 비용 | 장기적으로 감당 가능 | 사용자 가치 대비 유지보수 비용이 큼 |
+| 사용자 가치 | 핵심 기능, 즉시 필요 | nice-to-have, 후순위 가능 |
+
+Decision Gate 결과별 액션:
+- **타당** → DB 구현 후 API 구현으로 진행
+- **FE 수정** → DB에 맞게 FE를 조정한 후 API 구현 (같은 Phase 내)
+- **Phase 분리** → GitHub Issue를 생성하고, 현재 Phase에서 해당 기능 제외
+
+적용 범위:
+- FE/BE/DB가 모두 관련된 **신규 기능 구현**에 적용
+- FE-only, BE-only, DB-only 작업에는 건너뛰고 Step 3.1로 진행
+- 단순 CRUD처럼 DB 설계가 자명한 경우에도 건너뛰기 가능
+
 ### Step 3.1: 작은 단위로 코드 수정
 
 필수 원칙:

package/templates/global/hooks/workflow-enforced.sh

@@ -20,6 +20,7 @@ echo "✅ [Hook] 워크플로우 리마인더"
 
 cat << 'EOF'
 코드 작업 시 CLAUDE.md의 <workflow_protocol>을 따르세요.
+FE/BE/DB 관련 구현 시: FE → DB 설계 → Decision Gate → API 순서 (Step 3.0 참조)
 예외: 단순 오타/설정/1-2줄 수정 시 Phase 축소 가능
 
 ### 참조 가능한 Skills

package/templates/global/skills/Backend/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: Backend
-description: NestJS/TypeORM 백엔드 개발 시 사용. 레이어 객체 변환, find vs queryBuilder 선택 기준, BDD 테스트 작성 규칙 제공.
-keywords: [Backend, 백엔드, 레이어, DTO, Entity, Service, Controller, TypeORM, find, queryBuilder, test, BDD, 테스트, Jest]
+description: NestJS 백엔드 개발 시 사용. 레이어 객체 변환 규칙, BDD 테스트 작성 규칙 제공.
+keywords: [Backend, 백엔드, 레이어, DTO, Entity, Service, Controller, test, BDD, 테스트, Jest]
 user-invocable: false
 ---
 
@@ -90,78 +90,6 @@ async findOne(@Param('id') id: number) {
 
 ---
 
-<rules>
-
-## TypeORM 사용 규칙
-
-> **find 메서드를 기본으로 사용하고, QueryBuilder는 필요한 경우에만 사용한다.**
-
-### find 메서드 우선 사용
-
-```typescript
-// ✅ 기본 조회
-const user = await this.userRepository.findOneBy({ id });
-const users = await this.userRepository.find({
-  where: { status: 'active' },
-  relations: ['orders'],
-  order: { createdAt: 'DESC' },
-  take: 10,
-});
-
-// ✅ 조건 조합
-const users = await this.userRepository.find({
-  where: [
-    { status: 'active', role: 'admin' },
-    { status: 'active', role: 'manager' },
-  ],
-});
-```
-
-### QueryBuilder 허용 케이스
-
-**다음 경우에만 QueryBuilder 사용:**
-
-| 케이스 | 예시 |
-|--------|------|
-| **groupBy** | 집계 쿼리 |
-| **getRawMany/getRawOne** | 원시 데이터 필요 |
-| **복잡한 서브쿼리** | 중첩 쿼리 |
-| **복잡한 JOIN 조건** | ON 절 커스텀 |
-
-</rules>
-
-<examples>
-<example type="good">
-```typescript
-// ✅ QueryBuilder 허용: groupBy + getRawMany
-const stats = await this.orderRepository
-  .createQueryBuilder('order')
-  .select('order.status', 'status')
-  .addSelect('COUNT(*)', 'count')
-  .addSelect('SUM(order.amount)', 'total')
-  .groupBy('order.status')
-  .getRawMany();
-```
-</example>
-<example type="bad">
-```typescript
-// ❌ 불필요한 QueryBuilder 사용
-const user = await this.userRepository
-  .createQueryBuilder('user')
-  .where('user.id = :id', { id })
-  .getOne();
-```
-</example>
-<example type="good">
-```typescript
-// ✅ find로 대체
-const user = await this.userRepository.findOneBy({ id });
-```
-</example>
-</examples>
-
----
-
 <checklist>
 
 ## 체크리스트
@@ -170,8 +98,6 @@ const user = await this.userRepository.findOneBy({ id });
 - [ ] Service에서 Entity가 필요한 시점에 변환하는가?
 - [ ] Service의 return은 Entity 또는 일반 객체인가?
 - [ ] Controller에서 Response DTO/Schema로 변환하는가?
-- [ ] TypeORM find 메서드를 우선 사용하는가?
-- [ ] QueryBuilder는 groupBy, getRawMany 등 필요한 경우에만 사용하는가?
 
 </checklist>
 
@@ -181,6 +107,7 @@ const user = await this.userRepository.findOneBy({ id });
 
 | 주제 | 위치 | 설명 |
 |-----|------|------|
+| TypeORM 사용 규칙 | `TypeORM/SKILL.md` | find vs queryBuilder 선택 기준 |
 | BDD 테스트 | `bdd-testing.md` | NestJS + Jest BDD 스타일 테스트 작성 규칙 |
 
 </reference>