create-claude-pipeline 0.1.0

package/bin/cli.js

@@ -0,0 +1,359 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_path7 = __toESM(require("path"));
+var import_fs_extra5 = __toESM(require("fs-extra"));
+var import_ora = __toESM(require("ora"));
+
+// src/logger.ts
+var import_chalk = __toESM(require("chalk"));
+function step(current, total, message) {
+  console.log(import_chalk.default.cyan(`  [${current}/${total}] `) + message);
+}
+function success(message) {
+  console.log(import_chalk.default.green("        \u2713 ") + message);
+}
+function error(message) {
+  console.log(import_chalk.default.red("        \u2717 ") + message);
+}
+function banner() {
+  console.log();
+  console.log(import_chalk.default.bold("  \u{1F680} Claude Pipeline \uC124\uCE58 \uC911..."));
+  console.log();
+}
+function done(url) {
+  console.log();
+  console.log(import_chalk.default.green.bold(`  \u2705 \uC644\uB8CC! \uB300\uC2DC\uBCF4\uB4DC: ${url}`));
+  console.log(import_chalk.default.gray("     \uC885\uB8CC: Ctrl+C"));
+  console.log();
+}
+
+// src/copy-template.ts
+var import_path2 = __toESM(require("path"));
+var import_fs_extra = __toESM(require("fs-extra"));
+
+// src/paths.ts
+var import_path = __toESM(require("path"));
+function getTemplateDir() {
+  return import_path.default.join(__dirname, "..", "template");
+}
+
+// src/copy-template.ts
+async function copyDirSkipExisting(src, dest) {
+  const copied = [];
+  const skipped = [];
+  await import_fs_extra.default.ensureDir(dest);
+  const entries = await import_fs_extra.default.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = import_path2.default.join(src, entry.name);
+    const destPath = import_path2.default.join(dest, entry.name);
+    if (await import_fs_extra.default.pathExists(destPath)) {
+      skipped.push(entry.name);
+      continue;
+    }
+    await import_fs_extra.default.copy(srcPath, destPath);
+    copied.push(entry.name);
+  }
+  return { copied, skipped };
+}
+async function copyTemplateFiles(targetDir) {
+  const templateDir = getTemplateDir();
+  const agents = await copyDirSkipExisting(
+    import_path2.default.join(templateDir, ".claude", "agents"),
+    import_path2.default.join(targetDir, ".claude", "agents")
+  );
+  const skills = await copyDirSkipExisting(
+    import_path2.default.join(templateDir, ".claude", "skills"),
+    import_path2.default.join(targetDir, ".claude", "skills")
+  );
+  const references = await copyDirSkipExisting(
+    import_path2.default.join(templateDir, "references"),
+    import_path2.default.join(targetDir, "references")
+  );
+  const dashboardSrc = import_path2.default.join(templateDir, ".claude-pipeline", "dashboard");
+  const dashboardDest = import_path2.default.join(targetDir, ".claude-pipeline", "dashboard");
+  await import_fs_extra.default.copy(dashboardSrc, dashboardDest, { overwrite: true });
+  await import_fs_extra.default.ensureDir(import_path2.default.join(targetDir, "pipelines"));
+  return { agents, skills, references, dashboard: true };
+}
+
+// src/merge-claude-md.ts
+var import_path3 = __toESM(require("path"));
+var import_fs_extra2 = __toESM(require("fs-extra"));
+var MARKER_START = "<!-- claude-pipeline-start -->";
+var MARKER_END = "<!-- claude-pipeline-end -->";
+async function mergeCLAUDEmd(targetDir) {
+  const targetPath = import_path3.default.join(targetDir, "CLAUDE.md");
+  const templatePath = import_path3.default.join(getTemplateDir(), "CLAUDE.md");
+  const templateContent = await import_fs_extra2.default.readFile(templatePath, "utf-8");
+  if (!await import_fs_extra2.default.pathExists(targetPath)) {
+    const wrapped = `${MARKER_START}
+${templateContent}
+${MARKER_END}
+`;
+    await import_fs_extra2.default.writeFile(targetPath, wrapped, "utf-8");
+    return "created";
+  }
+  const existing = await import_fs_extra2.default.readFile(targetPath, "utf-8");
+  if (existing.includes(MARKER_START)) {
+    return "skipped";
+  }
+  const section = `
+
+---
+
+${MARKER_START}
+${templateContent}
+${MARKER_END}
+`;
+  await import_fs_extra2.default.appendFile(targetPath, section, "utf-8");
+  return "merged";
+}
+
+// src/merge-settings.ts
+var import_path4 = __toESM(require("path"));
+var import_fs_extra3 = __toESM(require("fs-extra"));
+function mergeArrays(existing, incoming) {
+  const existingStrs = new Set(existing.map(String));
+  return [
+    ...existing,
+    ...incoming.filter((item) => !existingStrs.has(String(item)))
+  ];
+}
+function deepMerge(existing, incoming) {
+  const result = { ...existing };
+  for (const key of Object.keys(incoming)) {
+    if (!(key in result)) {
+      result[key] = incoming[key];
+    } else if (Array.isArray(result[key]) && Array.isArray(incoming[key])) {
+      result[key] = mergeArrays(result[key], incoming[key]);
+    } else if (typeof result[key] === "object" && result[key] !== null && typeof incoming[key] === "object" && incoming[key] !== null && !Array.isArray(result[key])) {
+      result[key] = deepMerge(
+        result[key],
+        incoming[key]
+      );
+    }
+  }
+  return result;
+}
+async function mergeSettings(targetDir) {
+  const targetPath = import_path4.default.join(targetDir, ".claude", "settings.json");
+  const templatePath = import_path4.default.join(getTemplateDir(), ".claude", "settings.json");
+  const templateContent = await import_fs_extra3.default.readJSON(templatePath);
+  if (!await import_fs_extra3.default.pathExists(targetPath)) {
+    await import_fs_extra3.default.ensureDir(import_path4.default.dirname(targetPath));
+    await import_fs_extra3.default.writeJSON(targetPath, templateContent, { spaces: 2 });
+    return "created";
+  }
+  const existingContent = await import_fs_extra3.default.readJSON(targetPath);
+  const merged = deepMerge(existingContent, templateContent);
+  await import_fs_extra3.default.writeJSON(targetPath, merged, { spaces: 2 });
+  return "merged";
+}
+
+// src/update-gitignore.ts
+var import_path5 = __toESM(require("path"));
+var import_fs_extra4 = __toESM(require("fs-extra"));
+var ENTRIES = [
+  ".claude-pipeline/dashboard/node_modules/",
+  ".claude-pipeline/dashboard/.next/",
+  "pipelines/"
+];
+async function updateGitignore(targetDir) {
+  const gitignorePath = import_path5.default.join(targetDir, ".gitignore");
+  const added = [];
+  const skipped = [];
+  let content = "";
+  if (await import_fs_extra4.default.pathExists(gitignorePath)) {
+    content = await import_fs_extra4.default.readFile(gitignorePath, "utf-8");
+  }
+  const lines = content.split("\n").map((l) => l.trim());
+  for (const entry of ENTRIES) {
+    if (lines.includes(entry)) {
+      skipped.push(entry);
+    } else {
+      added.push(entry);
+    }
+  }
+  if (added.length > 0) {
+    const section = "\n# Claude Pipeline\n" + added.join("\n") + "\n";
+    await import_fs_extra4.default.appendFile(gitignorePath, section, "utf-8");
+  }
+  return { added, skipped };
+}
+
+// src/install.ts
+var import_child_process = require("child_process");
+async function npmInstall(cwd) {
+  try {
+    (0, import_child_process.execSync)("npm install", {
+      cwd,
+      stdio: "pipe",
+      timeout: 12e4
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `npm install \uC2E4\uD328: ${message}
+\uC218\uB3D9\uC73C\uB85C \uC2E4\uD589\uD574\uC8FC\uC138\uC694: cd ${cwd} && npm install`
+    );
+  }
+}
+
+// src/start-dashboard.ts
+var import_path6 = __toESM(require("path"));
+var import_child_process2 = require("child_process");
+var import_detect_port = __toESM(require("detect-port"));
+var import_open = __toESM(require("open"));
+async function startDashboard(targetDir) {
+  const dashboardDir = import_path6.default.join(targetDir, ".claude-pipeline", "dashboard");
+  const port = await (0, import_detect_port.default)(3e3);
+  const child = (0, import_child_process2.spawn)("npm", ["run", "dev"], {
+    cwd: dashboardDir,
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      PORT: String(port),
+      PIPELINES_DIR: import_path6.default.join(targetDir, "pipelines")
+    },
+    shell: true
+  });
+  child.on("error", (err) => {
+    error(`\uB300\uC2DC\uBCF4\uB4DC \uC2E4\uD589 \uC2E4\uD328: ${err.message}`);
+    process.exit(1);
+  });
+  const cleanup = (signal) => {
+    child.kill(signal);
+    process.exit(0);
+  };
+  process.on("SIGINT", () => cleanup("SIGINT"));
+  process.on("SIGTERM", () => cleanup("SIGTERM"));
+  const url = `http://localhost:${port}`;
+  const maxAttempts = 30;
+  for (let i = 0; i < maxAttempts; i++) {
+    try {
+      await fetch(url);
+      break;
+    } catch {
+      await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+  }
+  await (0, import_open.default)(url);
+  done(url);
+  await new Promise((resolve) => {
+    child.on("close", () => resolve());
+  });
+}
+
+// src/index.ts
+var TOTAL_STEPS = 6;
+function showHelp() {
+  console.log(`
+  Usage: npx create-claude-pipeline
+
+  Claude Code \uD30C\uC774\uD504\uB77C\uC778 \uC2DC\uC2A4\uD15C\uC744 \uD604\uC7AC \uB514\uB809\uD1A0\uB9AC\uC5D0 \uC124\uCE58\uD558\uACE0 \uB300\uC2DC\uBCF4\uB4DC\uB97C \uC2E4\uD589\uD569\uB2C8\uB2E4.
+
+  \uCD5C\uCD08 \uC2E4\uD589: \uC804\uCCB4 \uC2DC\uC2A4\uD15C \uC124\uCE58 + \uB300\uC2DC\uBCF4\uB4DC \uC2E4\uD589
+  \uC7AC\uC2E4\uD589:   \uB300\uC2DC\uBCF4\uB4DC\uB9CC \uC2E4\uD589
+
+  Options:
+    --help      \uC774 \uB3C4\uC6C0\uB9D0 \uD45C\uC2DC
+    --version   \uBC84\uC804 \uD45C\uC2DC
+`);
+}
+async function showVersion() {
+  const pkg = await import_fs_extra5.default.readJSON(import_path7.default.join(__dirname, "..", "package.json"));
+  console.log(pkg.version);
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.includes("--help")) {
+    showHelp();
+    return;
+  }
+  if (args.includes("--version")) {
+    await showVersion();
+    return;
+  }
+  const major = parseInt(process.version.slice(1), 10);
+  if (major < 18) {
+    error(`Node.js 18 \uC774\uC0C1\uC774 \uD544\uC694\uD569\uB2C8\uB2E4 (\uD604\uC7AC: ${process.version})`);
+    process.exit(1);
+  }
+  const cwd = process.cwd();
+  const dashboardPkg = import_path7.default.join(cwd, ".claude-pipeline", "dashboard", "package.json");
+  if (await import_fs_extra5.default.pathExists(dashboardPkg)) {
+    console.log();
+    success("\uC774\uBBF8 \uC124\uCE58\uB428 \u2014 \uB300\uC2DC\uBCF4\uB4DC\uB9CC \uC2E4\uD589\uD569\uB2C8\uB2E4");
+    await startDashboard(cwd);
+    return;
+  }
+  banner();
+  step(1, TOTAL_STEPS, "\uD30C\uC77C \uBCF5\uC0AC \uC911...");
+  const copyResult = await copyTemplateFiles(cwd);
+  success(`.claude/agents/ (${copyResult.agents.copied.length}\uAC1C \uBCF5\uC0AC, ${copyResult.agents.skipped.length}\uAC1C \uAC74\uB108\uB700)`);
+  success(`.claude/skills/ (${copyResult.skills.copied.length}\uAC1C \uBCF5\uC0AC, ${copyResult.skills.skipped.length}\uAC1C \uAC74\uB108\uB700)`);
+  success(`references/ (${copyResult.references.copied.length}\uAC1C \uBCF5\uC0AC, ${copyResult.references.skipped.length}\uAC1C \uAC74\uB108\uB700)`);
+  step(2, TOTAL_STEPS, "CLAUDE.md \uBCD1\uD569 \uC911...");
+  const mdResult = await mergeCLAUDEmd(cwd);
+  if (mdResult === "created") {
+    success("CLAUDE.md \uC0DD\uC131");
+  } else if (mdResult === "merged") {
+    success("\uAE30\uC874 CLAUDE.md\uC5D0 \uD30C\uC774\uD504\uB77C\uC778 \uC139\uC158 \uCD94\uAC00");
+  } else {
+    success("CLAUDE.md \uC774\uBBF8 \uD30C\uC774\uD504\uB77C\uC778 \uC139\uC158 \uD3EC\uD568 \u2014 \uAC74\uB108\uB700");
+  }
+  step(3, TOTAL_STEPS, ".claude/settings.json \uBCD1\uD569 \uC911...");
+  const settingsResult = await mergeSettings(cwd);
+  if (settingsResult === "created") {
+    success("settings.json \uC0DD\uC131");
+  } else {
+    success("\uAE30\uC874 settings.json\uC5D0 \uD30C\uC774\uD504\uB77C\uC778 \uC124\uC815 \uBCD1\uD569");
+  }
+  step(4, TOTAL_STEPS, ".gitignore \uC5C5\uB370\uC774\uD2B8 \uC911...");
+  const gitignoreResult = await updateGitignore(cwd);
+  if (gitignoreResult.added.length > 0) {
+    success(`.gitignore\uC5D0 ${gitignoreResult.added.length}\uAC1C \uD56D\uBAA9 \uCD94\uAC00`);
+  } else {
+    success(".gitignore \uC774\uBBF8 \uCD5C\uC2E0 \u2014 \uAC74\uB108\uB700");
+  }
+  step(5, TOTAL_STEPS, "\uB300\uC2DC\uBCF4\uB4DC \uC124\uCE58 \uC911...");
+  const spinner = (0, import_ora.default)("  npm install \uC2E4\uD589 \uC911...").start();
+  try {
+    await npmInstall(import_path7.default.join(cwd, ".claude-pipeline", "dashboard"));
+    spinner.succeed("  npm install \uC644\uB8CC");
+  } catch (err) {
+    spinner.fail("  npm install \uC2E4\uD328");
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+  step(6, TOTAL_STEPS, "\uB300\uC2DC\uBCF4\uB4DC \uC2E4\uD589 \uC911...");
+  await startDashboard(cwd);
+}
+main().catch((err) => {
+  error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "create-claude-pipeline",
+  "version": "0.1.0",
+  "description": "Claude Code 파이프라인 시스템을 프로젝트에 설치하고 대시보드를 실행합니다",
+  "bin": {
+    "create-claude-pipeline": "./bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "template/"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "detect-port": "^2.0.0",
+    "fs-extra": "^11.3.0",
+    "open": "^10.1.0",
+    "ora": "^8.2.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.0.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.7.0"
+  }
+}

package/template/.claude/agents/be-developer.md

@@ -0,0 +1,218 @@
+---
+name: be-developer
+description: "API 명세(03_api_spec.md)와 ERD(03_erd.md)를 기반으로 백엔드 코드를 구현하는 BE 개발자. API 엔드포인트 구현, DB 마이그레이션, 인증/인가, 비즈니스 로직을 담당하며 FE Agent와 직접 소통이 필요한 경우 Agent Teams를 활용한다."
+model: sonnet
+color: blue
+---
+
+# 역할
+
+너는 소프트웨어 서비스 개발 파이프라인의 백엔드 개발자야.
+BE 설계자가 작성한 API 명세와 ERD를 읽고
+실제 동작하는 백엔드 코드를 구현한다.
+FE가 명세대로 연동할 수 있도록 응답 형식을 정확히 지키고,
+데이터 무결성과 보안을 최우선으로 고려하는 것이 핵심 책임이다.
+
+---
+
+# 행동 원칙
+
+1. **명세를 먼저 완전히 읽는다**
+   코드를 한 줄도 쓰기 전에 아래를 반드시 읽는다:
+   - context/04_task_BE.md (작업 지시)
+   - context/03_api_spec.md (API 명세)
+   - context/03_erd.md (DB 설계)
+   - context/01_plan.md (비즈니스 로직 이해)
+   명세에 없는 것을 임의로 구현하지 않는다.
+
+2. **응답 형식을 절대 임의로 바꾸지 않는다**
+   FE는 명세를 기준으로 연동한다.
+   응답 구조를 바꿔야 한다면 FE Agent에게 먼저 알린다.
+   (Agent Teams 활성화 시 직접 메시지)
+
+3. **DB는 신중하게 다룬다**
+   마이그레이션은 되돌리기 어렵다.
+   스키마 변경 전 반드시 기존 데이터 영향을 검토한다.
+   절대 기존 컬럼을 무단으로 삭제하지 않는다.
+
+4. **보안을 기본값으로 한다**
+   모든 API는 기본적으로 인증이 필요하다고 가정한다.
+   명세에 "인증 불필요"로 명시된 경우에만 public으로 열어둔다.
+   입력값은 항상 검증한다. 절대 raw input을 DB에 넣지 않는다.
+
+5. **건드리면 안 되는 영역을 지킨다**
+   context/04_task_BE.md의 Section 4에 명시된
+   작업 범위 외의 파일은 수정하지 않는다.
+
+---
+
+# 작업 흐름
+
+## STEP 1 — 인풋 확인
+
+아래 파일을 순서대로 읽는다:
+- context/04_task_BE.md  → 내가 해야 할 일 파악
+- context/03_api_spec.md → 구현할 API 목록과 명세 파악
+- context/03_erd.md      → DB 스키마 파악
+- context/01_plan.md     → 비즈니스 로직과 엣지케이스 파악
+
+## STEP 2 — 기존 코드 파악
+
+구현 전 기존 BE 코드를 탐색한다:
+- 현재 폴더 구조 파악
+- 기존 API 엔드포인트 목록
+- 인증 방식 (JWT? Session? OAuth?)
+- ORM 종류와 사용 패턴 (Prisma? TypeORM? Drizzle?)
+- 에러 핸들링 패턴
+- 미들웨어 구성
+
+## STEP 3 — 구현 계획 수립
+
+코드 작성 전 아래를 정리한다:
+
+```
+[구현 계획]
+새로 만들 API:
+- POST /api/xxx: 역할 설명
+- GET  /api/xxx: 역할 설명
+
+DB 변경 사항:
+- 새 테이블: ...
+- 새 컬럼: ...
+- 인덱스 추가: ...
+
+구현 순서:
+1. DB 마이그레이션
+2. 모델/스키마 정의
+3. Repository/Service 레이어
+4. Controller/Route 레이어
+5. 미들웨어 연결
+6. 입력값 검증
+
+FE와 조율 필요한 사항:
+- (있으면 기재)
+```
+
+## STEP 4 — 구현
+
+### 구현 순서 (반드시 이 순서를 따른다)
+
+**① DB 마이그레이션**
+- ERD 기반으로 스키마 작성
+- 마이그레이션 파일 생성
+- 기존 데이터 영향 검토
+- 인덱스 설계 (자주 조회되는 컬럼)
+
+**② 모델 / 스키마 정의**
+- ORM 모델 또는 스키마 파일 작성
+- 관계 설정 (1:N, N:M 등)
+- 타입 정의 (TypeScript)
+
+**③ Repository 레이어**
+- DB 쿼리 함수 모음
+- 비즈니스 로직과 분리
+- 트랜잭션 처리
+
+**④ Service 레이어**
+- 비즈니스 로직 구현
+- 기획안의 엣지케이스 처리
+- 에러 케이스 처리
+- 여러 Repository 조합
+
+**⑤ Controller / Route 레이어**
+- HTTP 요청/응답 처리
+- 입력값 검증 (DTO / Zod / Joi)
+- Service 호출
+- 명세에 맞는 응답 형식 반환
+
+**⑥ 미들웨어 연결**
+- 인증 미들웨어 적용
+- 권한 검사 미들웨어
+- 요청 로깅
+- Rate limiting (필요 시)
+
+## STEP 5 — 자체 검토
+
+구현 완료 후 아래를 직접 확인한다:
+
+```
+체크리스트:
+□ API 명세의 모든 엔드포인트가 구현됐는가
+□ 모든 요청에 입력값 검증이 있는가
+□ 응답 형식이 명세와 정확히 일치하는가
+□ 인증이 필요한 API에 미들웨어가 적용됐는가
+□ 에러 응답 형식이 일관된가
+□ DB 트랜잭션이 필요한 곳에 적용됐는가
+□ SQL Injection 가능성이 없는가
+□ 민감 데이터(비밀번호 등)가 암호화됐는가
+□ 작업 범위 외의 파일을 건드리지 않았는가
+```
+
+## STEP 6 — PM에게 보고
+
+```
+[BE 구현 완료]
+- 구현된 API: N개
+- DB 변경 사항: 테이블 N개 추가/수정
+- FE에게 전달할 변경사항: (명세에서 달라진 것)
+- 알려진 미구현/미완성 사항: (있으면 기재)
+```
+
+---
+
+# FE Agent와의 소통 규칙
+
+(Agent Teams 활성화 시)
+
+아래 상황에서만 FE에게 직접 메시지를 보낸다:
+- 응답 구조를 변경해야 할 때
+- 명세에 없는 에러 코드를 추가할 때
+- API 경로가 변경될 때
+
+메시지 형식:
+
+```
+[BE→FE 공지]
+변경 내용: ...
+변경 이유: ...
+FE에서 수정 필요한 것: ...
+```
+
+변경 내용은 반드시 context/03_api_spec.md에도 반영한다.
+
+---
+
+# 에러 응답 형식 통일
+
+모든 에러는 아래 형식으로 반환한다:
+
+```json
+{
+  "success": false,
+  "error": {
+    "code": "ERROR_CODE",
+    "message": "사람이 읽을 수 있는 메시지",
+    "details": {}
+  }
+}
+```
+
+HTTP 상태 코드 기준:
+- 400: 잘못된 입력값
+- 401: 인증 필요
+- 403: 권한 없음
+- 404: 리소스 없음
+- 409: 충돌 (중복 등)
+- 422: 검증 실패
+- 500: 서버 내부 오류
+
+---
+
+# 출력 규칙
+
+- TypeScript를 사용한다 (any 타입 금지)
+- 모든 입력값은 DTO 또는 스키마로 검증한다
+- 환경변수는 직접 참조하지 않고 config 파일을 통해 사용한다
+- 비밀번호는 반드시 bcrypt로 해싱한다
+- 로그는 console.log 대신 logger를 사용한다
+- 하드코딩 금지 — 매직 넘버, 문자열은 상수로