@mandujs/core 0.12.0 → 0.12.2

package/README.ko.md

@@ -25,11 +25,16 @@ bun add @mandujs/core
 
 ```
 @mandujs/core
-├── spec/      # Spec 스키마 및 로딩
-├── generator/ # 코드 생성
+├── router/    # 파일 시스템 기반 라우팅
 ├── guard/     # 아키텍처 검사 및 자동 수정
-├── runtime/   # 서버 및 라우터
-└── report/    # Guard 리포트 생성
+├── runtime/   # 서버, SSR, 스트리밍
+├── filling/   # 핸들러 체인 API
+├── contract/  # 타입 안전 API 계약
+├── content/   # Content Layer - 빌드 타임 콘텐츠 로딩 🆕
+├── bundler/   # 클라이언트 번들링, HMR
+├── client/    # Island 하이드레이션, 클라이언트 라우터
+├── brain/     # Doctor, Watcher, 아키텍처 분석
+└── change/    # 트랜잭션 & 히스토리
 ```
 
 ## Spec 모듈
@@ -133,6 +138,73 @@ if (!result.passed) {
 | `COMPONENT_NOT_FOUND` | 컴포넌트 파일 없음 | ❌ |
 | `SLOT_NOT_FOUND` | slot 파일 없음 | ✅ |
 
+## Content Layer 🆕
+
+Astro에서 영감받은 빌드 타임 콘텐츠 로딩 시스템.
+
+```typescript
+// content.config.ts
+import { defineContentConfig, glob, file, api } from "@mandujs/core/content";
+import { z } from "zod";
+
+const postSchema = z.object({
+  title: z.string(),
+  date: z.coerce.date(),
+  tags: z.array(z.string()).default([]),
+});
+
+export default defineContentConfig({
+  collections: {
+    // Markdown 파일 (프론트매터 지원)
+    posts: {
+      loader: glob({ pattern: "content/posts/**/*.md" }),
+      schema: postSchema,
+    },
+    // 단일 JSON/YAML 파일
+    settings: {
+      loader: file({ path: "data/settings.json" }),
+    },
+    // 외부 API
+    products: {
+      loader: api({
+        url: "https://api.example.com/products",
+        cacheTTL: 3600,
+      }),
+    },
+  },
+});
+```
+
+### 콘텐츠 조회
+
+```typescript
+import { getCollection, getEntry } from "@mandujs/core/content";
+
+// 전체 컬렉션 조회
+const posts = await getCollection("posts");
+
+// 단일 엔트리 조회
+const post = await getEntry("posts", "hello-world");
+console.log(post?.data.title, post?.body);
+```
+
+### 내장 로더
+
+| 로더 | 설명 | 예시 |
+|------|------|------|
+| `file()` | 단일 파일 (JSON, YAML, TOML) | `file({ path: "data/config.json" })` |
+| `glob()` | 패턴 매칭 (Markdown, JSON) | `glob({ pattern: "content/**/*.md" })` |
+| `api()` | HTTP API (캐싱 지원) | `api({ url: "https://...", cacheTTL: 3600 })` |
+
+### 주요 기능
+
+- **Digest 기반 캐싱**: 변경된 파일만 재파싱
+- **Zod 검증**: 스키마 기반 타입 안전 콘텐츠
+- **프론트매터 지원**: Markdown YAML 프론트매터
+- **Dev 모드 감시**: 콘텐츠 변경 시 자동 리로드
+
+---
+
 ## Contract 모듈
 
 Zod 기반 계약(Contract) 정의 및 타입 안전 클라이언트 생성.
@@ -209,6 +281,11 @@ import type {
   GuardViolation,
   GenerateResult,
   AutoCorrectResult,
+  // Content Layer
+  DataEntry,
+  ContentConfig,
+  CollectionConfig,
+  Loader,
 } from "@mandujs/core";
 ```
 

package/README.md

@@ -81,6 +81,8 @@ const handlers = Mandu.handler(userContract, {
 ├── runtime/         # Server, SSR, streaming
 ├── filling/         # Handler chain API (Mandu.filling())
 ├── contract/        # Type-safe API contracts
+├── content/         # Content Layer - build-time content loading 🆕
+│   └── loaders      # file(), glob(), api() loaders
 ├── bundler/         # Client bundling, HMR
 ├── client/          # Island hydration, client router
 ├── brain/           # Doctor, Watcher, Architecture analyzer
@@ -453,6 +455,78 @@ function Navigation() {
 
 ---
 
+## Content Layer 🆕
+
+Astro-inspired build-time content loading system.
+
+```typescript
+// content.config.ts
+import { defineContentConfig, glob, file, api } from "@mandujs/core/content";
+import { z } from "zod";
+
+const postSchema = z.object({
+  title: z.string(),
+  date: z.coerce.date(),
+  tags: z.array(z.string()).default([]),
+});
+
+export default defineContentConfig({
+  collections: {
+    // Markdown files with frontmatter
+    posts: {
+      loader: glob({ pattern: "content/posts/**/*.md" }),
+      schema: postSchema,
+    },
+    // Single JSON/YAML file
+    settings: {
+      loader: file({ path: "data/settings.json" }),
+    },
+    // External API
+    products: {
+      loader: api({
+        url: "https://api.example.com/products",
+        headers: () => ({ Authorization: `Bearer ${process.env.API_KEY}` }),
+        cacheTTL: 3600,
+      }),
+    },
+  },
+});
+```
+
+### Querying Content
+
+```typescript
+import { getCollection, getEntry } from "@mandujs/core/content";
+
+// Get all entries
+const posts = await getCollection("posts");
+posts.forEach(post => {
+  console.log(post.id, post.data.title);
+});
+
+// Get single entry
+const post = await getEntry("posts", "hello-world");
+console.log(post?.data.title, post?.body);
+```
+
+### Built-in Loaders
+
+| Loader | Description | Example |
+|--------|-------------|---------|
+| `file()` | Single file (JSON, YAML, TOML) | `file({ path: "data/config.json" })` |
+| `glob()` | Pattern matching (Markdown, JSON) | `glob({ pattern: "content/**/*.md" })` |
+| `api()` | HTTP API with caching | `api({ url: "https://...", cacheTTL: 3600 })` |
+
+### Features
+
+- **Digest-based caching**: Only re-parse changed files
+- **Zod validation**: Type-safe content with schema validation
+- **Frontmatter support**: YAML frontmatter in Markdown files
+- **Dev mode watching**: Auto-reload on content changes
+- **Incremental updates**: Efficient builds with change detection
+
+---
+
 ## Brain (AI Assistant)
 
 Doctor and architecture analyzer.
@@ -551,6 +625,13 @@ import type {
 
   // Filling
   ManduContext,
+
+  // Content Layer
+  DataEntry,
+  ContentConfig,
+  CollectionConfig,
+  Loader,
+  LoaderContext,
 } from "@mandujs/core";
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mandujs/core",
-  "version": "0.12.0",
+  "version": "0.12.2",
   "description": "Mandu Framework Core - Spec, Generator, Guard, Runtime",
   "type": "module",
   "main": "./src/index.ts",
@@ -35,7 +35,7 @@
     "directory": "packages/core"
   },
   "author": "konamgil",
-  "license": "MIT",
+  "license": "MPL-2.0",
   "publishConfig": {
     "access": "public"
   },

package/src/guard/healing.ts

@@ -669,6 +669,8 @@ function getLayerHierarchy(preset?: GuardPreset): string {
       return "adapters → ports → domain";
     case "atomic":
       return "pages → templates → organisms → molecules → atoms";
+    case "cqrs":
+      return "api → commands|queries → dto/events → domain → shared";
     case "mandu":
       return "client(FSD) | shared | server(Clean)";
     default:

package/src/guard/index.ts

@@ -139,11 +139,13 @@ export {
   cleanPreset,
   hexagonalPreset,
   atomicPreset,
+  cqrsPreset,
   manduPreset,
   FSD_HIERARCHY,
   CLEAN_HIERARCHY,
   HEXAGONAL_HIERARCHY,
   ATOMIC_HIERARCHY,
+  CQRS_HIERARCHY,
 } from "./presets";
 
 // ═══════════════════════════════════════════════════════════════════════════

package/src/guard/negotiation.ts

@@ -118,7 +118,11 @@ export type FileTemplate =
   | "util"
   | "type"
   | "test"
-  | "slot";
+  | "slot"
+  | "command"
+  | "query"
+  | "event"
+  | "dto";
 
 /**
  * 협상 응답
@@ -438,6 +442,341 @@ const STRUCTURE_TEMPLATES: Record<FeatureCategory, (featureName: string) => Dire
   ],
 };
 
+// ═══════════════════════════════════════════════════════════════════════════
+// CQRS Structure Templates
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * CQRS 프리셋 전용 구조 템플릿
+ *
+ * application 레이어를 commands/queries/dto/events/mappers로 세분화
+ */
+const CQRS_STRUCTURE_TEMPLATES: Record<FeatureCategory, (featureName: string) => DirectoryProposal[]> = {
+  auth: (name) => [
+    {
+      path: `src/domain/${name}`,
+      purpose: `${name} 도메인 모델`,
+      layer: "domain",
+      files: [
+        { name: `${name}.entity.ts`, purpose: "사용자/인증 엔티티", template: "type" },
+        { name: `${name}.service.ts`, purpose: "도메인 서비스 인터페이스", template: "service" },
+        { name: `${name}.repository.ts`, purpose: "Repository 인터페이스", template: "repository" },
+      ],
+    },
+    {
+      path: `src/application/commands/${name}`,
+      purpose: `${name} 쓰기 경로`,
+      layer: "application/commands",
+      files: [
+        { name: `login.command.ts`, purpose: "로그인 커맨드 핸들러", template: "command" },
+        { name: `logout.command.ts`, purpose: "로그아웃 커맨드 핸들러", template: "command" },
+        { name: `refresh-token.command.ts`, purpose: "토큰 갱신 커맨드 핸들러", template: "command" },
+      ],
+    },
+    {
+      path: `src/application/queries/${name}`,
+      purpose: `${name} 읽기 경로`,
+      layer: "application/queries",
+      files: [
+        { name: `get-session.query.ts`, purpose: "세션 조회 쿼리 핸들러", template: "query" },
+        { name: `verify-token.query.ts`, purpose: "토큰 검증 쿼리 핸들러", template: "query" },
+      ],
+    },
+    {
+      path: `src/application/dto/${name}`,
+      purpose: `${name} DTO`,
+      layer: "application/dto",
+      files: [
+        { name: `login.dto.ts`, purpose: "로그인 요청/응답 DTO", template: "dto" },
+        { name: `token.dto.ts`, purpose: "토큰 DTO", template: "dto" },
+      ],
+    },
+    {
+      path: `src/application/events/${name}`,
+      purpose: `${name} 도메인 이벤트`,
+      layer: "application/events",
+      files: [
+        { name: `user-logged-in.event.ts`, purpose: "로그인 성공 이벤트", template: "event" },
+        { name: `user-logged-out.event.ts`, purpose: "로그아웃 이벤트", template: "event" },
+      ],
+    },
+    {
+      path: `src/infra/${name}`,
+      purpose: `${name} 인프라 어댑터`,
+      layer: "infrastructure",
+      files: [
+        { name: `token.provider.ts`, purpose: "토큰 생성/검증 구현", template: "service" },
+        { name: `session.repository.ts`, purpose: "세션 저장소 구현", template: "repository" },
+      ],
+    },
+    {
+      path: `src/api/${name}`,
+      purpose: `${name} API 라우트`,
+      layer: "api",
+      files: [
+        { name: `login/route.ts`, purpose: "로그인 API → LoginCommand 디스패치", template: "route", isSlot: true },
+        { name: `logout/route.ts`, purpose: "로그아웃 API → LogoutCommand 디스패치", template: "route", isSlot: true },
+        { name: `refresh/route.ts`, purpose: "토큰 갱신 API → RefreshTokenCommand 디스패치", template: "route", isSlot: true },
+        { name: `session/route.ts`, purpose: "세션 조회 API → GetSessionQuery 디스패치", template: "route", isSlot: true },
+      ],
+    },
+  ],
+
+  crud: (name) => [
+    {
+      path: `src/domain/${name}`,
+      purpose: `${name} 도메인`,
+      layer: "domain",
+      files: [
+        { name: `${name}.entity.ts`, purpose: "엔티티 정의", template: "type" },
+        { name: `${name}.repository.ts`, purpose: "Repository 인터페이스", template: "repository" },
+      ],
+    },
+    {
+      path: `src/application/commands/${name}`,
+      purpose: `${name} 쓰기 커맨드`,
+      layer: "application/commands",
+      files: [
+        { name: `create-${name}.command.ts`, purpose: "생성 커맨드 핸들러", template: "command" },
+        { name: `update-${name}.command.ts`, purpose: "수정 커맨드 핸들러", template: "command" },
+        { name: `delete-${name}.command.ts`, purpose: "삭제 커맨드 핸들러", template: "command" },
+      ],
+    },
+    {
+      path: `src/application/queries/${name}`,
+      purpose: `${name} 읽기 쿼리`,
+      layer: "application/queries",
+      files: [
+        { name: `get-${name}.query.ts`, purpose: "단건 조회 쿼리 핸들러", template: "query" },
+        { name: `list-${name}.query.ts`, purpose: "목록 조회 쿼리 핸들러", template: "query" },
+      ],
+    },
+    {
+      path: `src/application/dto/${name}`,
+      purpose: `${name} DTO`,
+      layer: "application/dto",
+      files: [
+        { name: `create-${name}.dto.ts`, purpose: "생성 요청 DTO", template: "dto" },
+        { name: `update-${name}.dto.ts`, purpose: "수정 요청 DTO", template: "dto" },
+        { name: `${name}-response.dto.ts`, purpose: "응답 DTO", template: "dto" },
+      ],
+    },
+    {
+      path: `src/infra/${name}`,
+      purpose: `${name} Repository 구현`,
+      layer: "infrastructure",
+      files: [
+        { name: `${name}.repository-impl.ts`, purpose: "Repository 구현체", template: "repository" },
+      ],
+    },
+    {
+      path: `src/api/${name}`,
+      purpose: `${name} API`,
+      layer: "api",
+      files: [
+        { name: `route.ts`, purpose: "목록/생성 API (GET→ListQuery, POST→CreateCommand)", template: "route", isSlot: true },
+        { name: `[id]/route.ts`, purpose: "상세/수정/삭제 API (GET→GetQuery, PUT→UpdateCommand, DELETE→DeleteCommand)", template: "route", isSlot: true },
+      ],
+    },
+  ],
+
+  api: (name) => [
+    {
+      path: `src/domain/${name}`,
+      purpose: `${name} 도메인`,
+      layer: "domain",
+      files: [
+        { name: `${name}.service.ts`, purpose: "도메인 서비스", template: "service" },
+        { name: `${name}.types.ts`, purpose: "타입 정의", template: "type" },
+      ],
+    },
+    {
+      path: `src/application/commands/${name}`,
+      purpose: `${name} 커맨드`,
+      layer: "application/commands",
+      files: [
+        { name: `${name}.command.ts`, purpose: "커맨드 핸들러", template: "command" },
+      ],
+    },
+    {
+      path: `src/application/queries/${name}`,
+      purpose: `${name} 쿼리`,
+      layer: "application/queries",
+      files: [
+        { name: `${name}.query.ts`, purpose: "쿼리 핸들러", template: "query" },
+      ],
+    },
+    {
+      path: `src/api/${name}`,
+      purpose: `${name} API 엔드포인트`,
+      layer: "api",
+      files: [
+        { name: `route.ts`, purpose: "API 핸들러 → Command/Query 디스패치", template: "route", isSlot: true },
+      ],
+    },
+  ],
+
+  ui: (name) => [
+    {
+      path: `src/application/queries/${name}`,
+      purpose: `${name} 데이터 조회`,
+      layer: "application/queries",
+      files: [
+        { name: `get-${name}.query.ts`, purpose: "UI용 데이터 조회 쿼리", template: "query" },
+      ],
+    },
+    {
+      path: `src/application/dto/${name}`,
+      purpose: `${name} DTO`,
+      layer: "application/dto",
+      files: [
+        { name: `${name}-view.dto.ts`, purpose: "뷰 모델 DTO", template: "dto" },
+      ],
+    },
+    {
+      path: `src/api/${name}`,
+      purpose: `${name} API`,
+      layer: "api",
+      files: [
+        { name: `route.ts`, purpose: "UI 데이터 API", template: "route", isSlot: true },
+      ],
+    },
+  ],
+
+  integration: (name) => [
+    {
+      path: `src/domain/${name}`,
+      purpose: `${name} 도메인 포트`,
+      layer: "domain",
+      files: [
+        { name: `${name}.port.ts`, purpose: "포트 인터페이스", template: "type" },
+      ],
+    },
+    {
+      path: `src/application/commands/${name}`,
+      purpose: `${name} 동기화 커맨드`,
+      layer: "application/commands",
+      files: [
+        { name: `sync-${name}.command.ts`, purpose: "외부 서비스 동기화 커맨드", template: "command" },
+      ],
+    },
+    {
+      path: `src/application/events/${name}`,
+      purpose: `${name} 연동 이벤트`,
+      layer: "application/events",
+      files: [
+        { name: `${name}-synced.event.ts`, purpose: "동기화 완료 이벤트", template: "event" },
+      ],
+    },
+    {
+      path: `src/infra/${name}`,
+      purpose: `${name} 외부 서비스 어댑터`,
+      layer: "infrastructure",
+      files: [
+        { name: `${name}.client.ts`, purpose: "외부 API 클라이언트", template: "service" },
+        { name: `${name}.config.ts`, purpose: "연동 설정", template: "util" },
+      ],
+    },
+    {
+      path: `src/api/webhooks/${name}`,
+      purpose: `${name} 웹훅`,
+      layer: "api",
+      files: [
+        { name: `route.ts`, purpose: "웹훅 핸들러", template: "route", isSlot: true },
+      ],
+    },
+  ],
+
+  data: (name) => [
+    {
+      path: `src/domain/${name}`,
+      purpose: `${name} 데이터 처리 도메인`,
+      layer: "domain",
+      files: [
+        { name: `${name}.types.ts`, purpose: "타입 정의", template: "type" },
+      ],
+    },
+    {
+      path: `src/application/commands/${name}`,
+      purpose: `${name} 데이터 처리 커맨드`,
+      layer: "application/commands",
+      files: [
+        { name: `import-${name}.command.ts`, purpose: "데이터 임포트 커맨드", template: "command" },
+        { name: `transform-${name}.command.ts`, purpose: "데이터 변환 커맨드", template: "command" },
+      ],
+    },
+    {
+      path: `src/application/queries/${name}`,
+      purpose: `${name} 데이터 조회`,
+      layer: "application/queries",
+      files: [
+        { name: `export-${name}.query.ts`, purpose: "데이터 익스포트 쿼리", template: "query" },
+      ],
+    },
+    {
+      path: `src/application/dto/${name}`,
+      purpose: `${name} DTO`,
+      layer: "application/dto",
+      files: [
+        { name: `${name}-import.dto.ts`, purpose: "임포트 DTO", template: "dto" },
+      ],
+    },
+  ],
+
+  util: (name) => [
+    {
+      path: `src/shared/${name}`,
+      purpose: `${name} 유틸리티`,
+      layer: "shared",
+      files: [
+        { name: `${name}.ts`, purpose: "유틸리티 함수", template: "util" },
+        { name: `${name}.test.ts`, purpose: "테스트", template: "test" },
+        { name: `index.ts`, purpose: "Public API", template: "util" },
+      ],
+    },
+  ],
+
+  config: (name) => [
+    {
+      path: `src/shared/config`,
+      purpose: "설정 관리",
+      layer: "shared",
+      files: [
+        { name: `${name}.config.ts`, purpose: `${name} 설정`, template: "util" },
+        { name: `${name}.schema.ts`, purpose: "설정 스키마 (Zod)", template: "type" },
+      ],
+    },
+  ],
+
+  other: (name) => [
+    {
+      path: `src/domain/${name}`,
+      purpose: `${name} 도메인`,
+      layer: "domain",
+      files: [
+        { name: `${name}.service.ts`, purpose: "도메인 서비스", template: "service" },
+        { name: `${name}.types.ts`, purpose: "타입 정의", template: "type" },
+      ],
+    },
+    {
+      path: `src/application/commands/${name}`,
+      purpose: `${name} 커맨드`,
+      layer: "application/commands",
+      files: [
+        { name: `${name}.command.ts`, purpose: "커맨드 핸들러", template: "command" },
+      ],
+    },
+    {
+      path: `src/application/queries/${name}`,
+      purpose: `${name} 쿼리`,
+      layer: "application/queries",
+      files: [
+        { name: `${name}.query.ts`, purpose: "쿼리 핸들러", template: "query" },
+      ],
+    },
+  ],
+};
+
 // ═══════════════════════════════════════════════════════════════════════════
 // File Templates
 // ═══════════════════════════════════════════════════════════════════════════
@@ -557,6 +896,91 @@ describe("${name}", () => {
     expect(true).toBe(true);
   });
 });
+`;
+
+    case "command":
+      return `/**
+ * ${purpose}
+ *
+ * Command Handler - 쓰기 경로
+ */
+
+export interface ${toPascalCase(name)}Command {
+  // TODO: Define command payload
+}
+
+export interface ${toPascalCase(name)}Result {
+  // TODO: Define command result
+}
+
+export class ${toPascalCase(name)}Handler {
+  async execute(command: ${toPascalCase(name)}Command): Promise<${toPascalCase(name)}Result> {
+    // TODO: Implement command handler
+    throw new Error("Not implemented");
+  }
+}
+`;
+
+    case "query":
+      return `/**
+ * ${purpose}
+ *
+ * Query Handler - 읽기 경로
+ */
+
+export interface ${toPascalCase(name)}Query {
+  // TODO: Define query parameters
+}
+
+export interface ${toPascalCase(name)}Result {
+  // TODO: Define query result
+}
+
+export class ${toPascalCase(name)}Handler {
+  async execute(query: ${toPascalCase(name)}Query): Promise<${toPascalCase(name)}Result> {
+    // TODO: Implement query handler
+    throw new Error("Not implemented");
+  }
+}
+`;
+
+    case "event":
+      return `/**
+ * ${purpose}
+ *
+ * Domain Event
+ */
+
+export interface ${toPascalCase(name)}Event {
+  readonly type: "${name}";
+  readonly occurredAt: Date;
+  // TODO: Define event payload
+}
+
+export function create${toPascalCase(name)}Event(
+  // TODO: Define factory parameters
+): ${toPascalCase(name)}Event {
+  return {
+    type: "${name}",
+    occurredAt: new Date(),
+  };
+}
+`;
+
+    case "dto":
+      return `/**
+ * ${purpose}
+ *
+ * Data Transfer Object
+ */
+
+export interface ${toPascalCase(name)}Dto {
+  // TODO: Define DTO fields
+}
+
+export interface ${toPascalCase(name)}ResponseDto {
+  // TODO: Define response DTO fields
+}
 `;
 
     case "util":
@@ -659,6 +1083,7 @@ function adjustStructureForPreset(
       "shared": "src/utils",
       "app/api": "src/api",
     },
+    cqrs: {},  // CQRS 전용 템플릿이 자체 경로 사용
     mandu: {}, // 기본값, 매핑 불필요
   };
 
@@ -716,11 +1141,12 @@ export async function negotiate(
 
   // 4. 프리셋 정의 로드 및 구조 템플릿 선택
   const presetDef = getPreset(preset);
-  const templateFn = STRUCTURE_TEMPLATES[category] || STRUCTURE_TEMPLATES.other;
+  const templates = preset === "cqrs" ? CQRS_STRUCTURE_TEMPLATES : STRUCTURE_TEMPLATES;
+  const templateFn = templates[category] || templates.other;
   let structure = templateFn(featureName);
 
-  // 5. 프리셋에 따른 구조 조정
-  if (presetDef && preset !== "mandu") {
+  // 5. 프리셋에 따른 구조 조정 (cqrs, mandu는 자체 경로 사용)
+  if (presetDef && preset !== "mandu" && preset !== "cqrs") {
     structure = adjustStructureForPreset(structure, presetDef, preset);
   }
 

package/src/guard/presets/cqrs.test.ts

@@ -0,0 +1,154 @@
+/**
+ * CQRS Preset Tests
+ *
+ * CQRS 프리셋의 구조 검증 및 Command/Query 분리 규칙 테스트
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from "bun:test";
+import { mkdtemp, rm, mkdir } from "fs/promises";
+import { join } from "path";
+import { tmpdir } from "os";
+import { cqrsPreset, CQRS_HIERARCHY } from "./cqrs";
+import { presets, getPreset } from "./index";
+import { negotiate, generateScaffold } from "../negotiation";
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Preset Structure Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+describe("CQRS Preset - Structure", () => {
+  it("should be registered in presets map", () => {
+    expect(presets.cqrs).toBeDefined();
+    expect(presets.cqrs).toBe(cqrsPreset);
+  });
+
+  it("should be retrievable via getPreset", () => {
+    expect(getPreset("cqrs")).toBe(cqrsPreset);
+  });
+
+  it("should have correct name and description", () => {
+    expect(cqrsPreset.name).toBe("cqrs");
+    expect(cqrsPreset.description).toContain("CQRS");
+  });
+
+  it("should define all 10 layers", () => {
+    expect(cqrsPreset.layers).toHaveLength(10);
+  });
+
+  it("should have hierarchy matching layer names", () => {
+    const layerNames = cqrsPreset.layers.map((l) => l.name);
+    for (const h of CQRS_HIERARCHY) {
+      expect(layerNames).toContain(h);
+    }
+  });
+
+  it("should set layerViolation severity to error", () => {
+    expect(cqrsPreset.defaultSeverity?.layerViolation).toBe("error");
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// CQRS Separation Rules - TODO(human)
+// ═══════════════════════════════════════════════════════════════════════════
+
+describe("CQRS Preset - Command/Query Separation", () => {
+  // TODO(human): CQRS 분리 규칙 검증 테스트를 작성하세요.
+  //
+  // 힌트:
+  //   - cqrsPreset.layers 배열에서 특정 레이어를 찾으려면:
+  //     const commandsLayer = cqrsPreset.layers.find(l => l.name === "application/commands");
+  //   - commandsLayer.canImport 배열에 특정 레이어가 포함/미포함인지 검증
+  //
+  // 작성해야 할 테스트 케이스:
+  //   1. commands는 queries를 import할 수 없어야 함
+  //   2. queries는 commands와 events를 import할 수 없어야 함
+  //   3. commands는 domain, dto, events를 import할 수 있어야 함
+  //   4. queries는 domain, dto를 import할 수 있어야 함
+  //   5. domain은 shared만 import할 수 있어야 함
+  //   6. shared는 아무것도 import할 수 없어야 함
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// CQRS Scaffolding Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+let SCAFFOLD_DIR: string;
+
+beforeAll(async () => {
+  SCAFFOLD_DIR = await mkdtemp(join(tmpdir(), "test-cqrs-scaffold-"));
+  await mkdir(join(SCAFFOLD_DIR, "spec", "decisions"), { recursive: true });
+});
+
+afterAll(async () => {
+  await rm(SCAFFOLD_DIR, { recursive: true, force: true });
+});
+
+describe("CQRS Preset - Scaffold Templates", () => {
+  it("should generate commands/queries separation for auth", async () => {
+    const result = await negotiate(
+      { intent: "사용자 인증 추가", category: "auth", preset: "cqrs" },
+      SCAFFOLD_DIR,
+    );
+
+    expect(result.approved).toBe(true);
+    expect(result.preset).toBe("cqrs");
+
+    const paths = result.structure.map((s) => s.path);
+    expect(paths.some((p) => p.includes("application/commands"))).toBe(true);
+    expect(paths.some((p) => p.includes("application/queries"))).toBe(true);
+    expect(paths.some((p) => p.includes("application/dto"))).toBe(true);
+    expect(paths.some((p) => p.includes("application/events"))).toBe(true);
+  });
+
+  it("should generate CRUD with separate commands and queries", async () => {
+    const result = await negotiate(
+      { intent: "상품 관리 CRUD", category: "crud", preset: "cqrs" },
+      SCAFFOLD_DIR,
+    );
+
+    const commandsDir = result.structure.find((s) => s.path.includes("application/commands"));
+    const queriesDir = result.structure.find((s) => s.path.includes("application/queries"));
+
+    expect(commandsDir).toBeDefined();
+    expect(queriesDir).toBeDefined();
+
+    // commands에 create/update/delete가 있어야 함
+    const cmdFiles = commandsDir!.files.map((f) => f.name);
+    expect(cmdFiles.some((f) => f.includes("create"))).toBe(true);
+    expect(cmdFiles.some((f) => f.includes("update"))).toBe(true);
+    expect(cmdFiles.some((f) => f.includes("delete"))).toBe(true);
+
+    // queries에 get/list가 있어야 함
+    const qryFiles = queriesDir!.files.map((f) => f.name);
+    expect(qryFiles.some((f) => f.includes("get"))).toBe(true);
+    expect(qryFiles.some((f) => f.includes("list"))).toBe(true);
+  });
+
+  it("should create actual scaffold files", async () => {
+    const testDir = await mkdtemp(join(SCAFFOLD_DIR, "actual-"));
+    await mkdir(join(testDir, "spec", "decisions"), { recursive: true });
+
+    const plan = await negotiate(
+      { intent: "order feature", category: "crud", preset: "cqrs" },
+      testDir,
+    );
+    const result = await generateScaffold(plan.structure, testDir);
+
+    expect(result.success).toBe(true);
+    expect(result.createdFiles.some((f) => f.includes("command"))).toBe(true);
+    expect(result.createdFiles.some((f) => f.includes("query"))).toBe(true);
+  });
+
+  it("should use src/ prefixed paths (no adjustStructureForPreset)", async () => {
+    const result = await negotiate(
+      { intent: "payment api", category: "api", preset: "cqrs" },
+      SCAFFOLD_DIR,
+    );
+
+    // CQRS 전용 템플릿은 이미 src/ 기준 경로를 사용
+    const paths = result.structure.map((s) => s.path);
+    for (const p of paths) {
+      expect(p.startsWith("src/")).toBe(true);
+    }
+  });
+});

package/src/guard/presets/cqrs.ts

@@ -0,0 +1,107 @@
+/**
+ * CQRS Preset
+ *
+ * Command Query Responsibility Segregation 아키텍처
+ * 쓰기 경로(Commands)와 읽기 경로(Queries)의 격리를 프레임워크 레벨에서 강제
+ */
+
+import type { PresetDefinition } from "../types";
+
+/**
+ * CQRS 레이어 계층 구조
+ *
+ * 의존성: 외부 → 내부 (domain이 핵심)
+ * commands와 queries는 서로 격리됨
+ */
+export const CQRS_HIERARCHY = [
+  "api",
+  "infra",
+  "application/commands",
+  "application/queries",
+  "application/dto",
+  "application/mappers",
+  "application/events",
+  "domain",
+  "core",
+  "shared",
+] as const;
+
+/**
+ * CQRS 프리셋 정의
+ */
+export const cqrsPreset: PresetDefinition = {
+  name: "cqrs",
+  description: "CQRS - Command/Query 분리 아키텍처",
+
+  hierarchy: [...CQRS_HIERARCHY],
+
+  layers: [
+    {
+      name: "api",
+      pattern: "src/**/api/**",
+      canImport: ["application/commands", "application/queries", "application/dto", "core", "shared"],
+      description: "Controllers, Routes - Command/Query 디스패치",
+    },
+    {
+      name: "infra",
+      pattern: "src/**/infra/**",
+      canImport: ["application/commands", "application/queries", "domain", "core", "shared"],
+      description: "Repository 구현, 외부 서비스 어댑터",
+    },
+    {
+      name: "application/commands",
+      pattern: "src/**/application/commands/**",
+      canImport: ["domain", "application/dto", "application/events", "core", "shared"],
+      description: "Command Handlers - 쓰기 경로 (queries 접근 불가)",
+    },
+    {
+      name: "application/queries",
+      pattern: "src/**/application/queries/**",
+      canImport: ["domain", "application/dto", "core", "shared"],
+      description: "Query Handlers - 읽기 경로 (commands, events 접근 불가)",
+    },
+    {
+      name: "application/dto",
+      pattern: "src/**/application/dto/**",
+      canImport: ["domain", "shared"],
+      description: "Data Transfer Objects",
+    },
+    {
+      name: "application/mappers",
+      pattern: "src/**/application/mappers/**",
+      canImport: ["domain", "application/dto", "shared"],
+      description: "Domain ↔ DTO 변환기",
+    },
+    {
+      name: "application/events",
+      pattern: "src/**/application/events/**",
+      canImport: ["domain", "shared"],
+      description: "Domain Events, Integration Events",
+    },
+    {
+      name: "domain",
+      pattern: "src/**/domain/**",
+      canImport: ["shared"],
+      description: "Entities, Value Objects, Domain Services, Aggregates",
+    },
+    {
+      name: "core",
+      pattern: "src/core/**",
+      canImport: ["shared"],
+      description: "공통 핵심 (auth, config, errors, CQRS bus)",
+    },
+    {
+      name: "shared",
+      pattern: "src/shared/**",
+      canImport: [],
+      description: "공유 유틸리티, 타입, 인터페이스",
+    },
+  ],
+
+  defaultSeverity: {
+    layerViolation: "error",
+    circularDependency: "error",
+    crossSliceDependency: "warn",
+    deepNesting: "info",
+  },
+};

package/src/guard/presets/index.ts

@@ -9,12 +9,14 @@ import { fsdPreset, FSD_HIERARCHY } from "./fsd";
 import { cleanPreset, CLEAN_HIERARCHY } from "./clean";
 import { hexagonalPreset, HEXAGONAL_HIERARCHY } from "./hexagonal";
 import { atomicPreset, ATOMIC_HIERARCHY } from "./atomic";
+import { cqrsPreset, CQRS_HIERARCHY } from "./cqrs";
 
 // Re-export
 export { fsdPreset, FSD_HIERARCHY } from "./fsd";
 export { cleanPreset, CLEAN_HIERARCHY } from "./clean";
 export { hexagonalPreset, HEXAGONAL_HIERARCHY } from "./hexagonal";
 export { atomicPreset, ATOMIC_HIERARCHY } from "./atomic";
+export { cqrsPreset, CQRS_HIERARCHY } from "./cqrs";
 
 /**
  * Mandu 권장 프리셋 (FSD + Clean 조합)
@@ -263,6 +265,7 @@ export const presets: Record<GuardPreset, PresetDefinition> = {
   clean: cleanPreset,
   hexagonal: hexagonalPreset,
   atomic: atomicPreset,
+  cqrs: cqrsPreset,
   mandu: manduPreset,
 };
 

package/src/guard/suggestions.ts

@@ -35,6 +35,12 @@ const DOCS: Record<GuardPreset | "default", Record<string, string>> = {
     molecules: "https://bradfrost.com/blog/post/atomic-web-design/#molecules",
     organisms: "https://bradfrost.com/blog/post/atomic-web-design/#organisms",
   },
+  cqrs: {
+    base: "https://learn.microsoft.com/en-us/azure/architecture/patterns/cqrs",
+    commands: "https://learn.microsoft.com/en-us/azure/architecture/patterns/cqrs#solution",
+    queries: "https://learn.microsoft.com/en-us/azure/architecture/patterns/cqrs#solution",
+    layers: "https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html",
+  },
   mandu: {
     base: "https://github.com/mandujs/mandu/docs/guard",
     layers: "https://github.com/mandujs/mandu/docs/guard#layers",

package/src/guard/types.ts

@@ -20,6 +20,7 @@ export type GuardPreset =
   | "clean"      // Clean Architecture
   | "hexagonal"  // Hexagonal Architecture
   | "atomic"     // Atomic Design
+  | "cqrs"       // CQRS (Command Query Responsibility Segregation)
   | "mandu";     // Mandu 권장 (FSD + Clean 조합)
 
 /**