oh-my-oop 0.2.0

package/dist/validate/emptyObjectFill.js

@@ -0,0 +1,119 @@
+import { assertHasMultipleRemedies } from "./findings.js";
+// "빈 객체 + 외부 채우기" 안티패턴 — invariant 시간차.
+// 대표 사례: val result = WinningResult(); lottos.forEach { result.add(rank) }
+// 생성 시점엔 *불완전*, 사용 시점엔 *완전* — Tell-Don't-Ask 위반.
+// woowacourse/kotlin-lotto PR #14 (@malibinYun)에서 정확히 이 패턴 지적.
+const MUTATION_VERBS = [
+    // 한국어 동사 어간
+    "추가",
+    "누적",
+    "채우",
+    "세팅",
+    "등록",
+    "담",
+    "모으",
+    "쌓",
+    // 영어 동사
+    "add",
+    "append",
+    "put",
+    "set",
+    "record",
+    "register",
+    "collect",
+    "accumulate",
+];
+function matchedVerbs(text) {
+    const lower = text.toLowerCase();
+    return MUTATION_VERBS.filter((v) => lower.includes(v.toLowerCase()));
+}
+export function checkEmptyObjectFill(design) {
+    const out = [];
+    for (const card of design.classes) {
+        if (card.stereotype !== "InformationHolder")
+            continue;
+        if (card.responsibilities.knowing.length !== 0)
+            continue;
+        const doings = card.responsibilities.doing;
+        if (doings.length === 0)
+            continue;
+        const perDoingMatches = doings.map((d) => matchedVerbs(d));
+        const allMutation = perDoingMatches.every((m) => m.length > 0);
+        if (!allMutation)
+            continue;
+        const matchedSet = new Set();
+        for (const m of perDoingMatches)
+            for (const v of m)
+                matchedSet.add(v);
+        out.push(assertHasMultipleRemedies({
+            rule_id: "empty-object-external-fill",
+            severity: "warn",
+            target: { kind: "class", id: card.id },
+            message: `${card.name}은(는) InformationHolder인데 knowing이 비어 있고 doing이 모두 *외부에서 채우는* 동사로만 ` +
+                `구성되어 있습니다. *빈 껍데기 + 외부 조립* 패턴은 invariant 시간차(생성 시점엔 불완전, 사용 시점엔 완전)를 만듭니다.`,
+            evidence: {
+                stereotype: card.stereotype,
+                knowing_count: 0,
+                doing_count: doings.length,
+                mutation_verbs_matched: [...matchedSet],
+                example_doing: doings[0],
+                guideline: "@malibinYun (lotto PR #14): \"빈 껍데기의 WinningResult를 만들어서 값을 채우기보다, " +
+                    "WinningResult를 직접 만들어서 반환하는 것은 어떨까요?\" — " +
+                    "빈 객체 + 외부 채우기 = invariant 시간차. Tell-Don't-Ask 위반.",
+            },
+            remedies: [
+                {
+                    label: "팩토리/부생성자로 *완성된* 객체 반환",
+                    summary: `외부 루프에서 add를 반복하는 대신, 입력 컬렉션을 받아 한 번에 채우는 팩토리(또는 부생성자)로 ` +
+                        `생성 시점에 invariant를 즉시 충족시킨다. ` +
+                        `예: ${card.name}(items.map { it.toRank() }) 또는 ${card.name}.from(items, criteria).`,
+                    tradeoffs: {
+                        pros: [
+                            "생성 시점에 invariant 즉시 충족 (불완전 상태가 외부에 노출되지 않음)",
+                            "호출자가 add 호출 순서/누락을 신경 쓸 필요 없음",
+                            "Tell-Don't-Ask: 호출자는 데이터만 넘기고 채우는 책임은 객체 내부에 위치",
+                        ],
+                        cons: [
+                            "스트리밍·점진 누적이 정당한 도메인에는 부적합",
+                            "팩토리 시그니처가 입력 컬렉션 타입에 결합됨",
+                        ],
+                    },
+                },
+                {
+                    label: "Builder + 완성품 *타입 분리*",
+                    summary: `조립 중 객체와 완성된 객체를 *다른 타입*으로 나눈다. ` +
+                        `${card.name}Builder(가변, add 가능) → .build() → ${card.name}(불변, invariant 검증 완료). ` +
+                        `호출부는 빌더만 만지고 도메인 코드는 완성품만 본다.`,
+                    tradeoffs: {
+                        pros: [
+                            "조립 중/완성된 객체가 *타입으로 구분*되어 시간차 위반이 컴파일 단계에서 차단",
+                            "다단계 조건부 조립을 자연스럽게 표현할 수 있음",
+                        ],
+                        cons: [
+                            "객체 수가 1개 늘어 초기 학습 비용 증가",
+                            "단순한 컬렉션 매핑 수준의 도메인에는 과추상화",
+                        ],
+                    },
+                },
+                {
+                    label: "현 패턴 유지 + 사용 시점 invariant 검증",
+                    summary: `외부 채우기 흐름을 유지하되, 값을 읽는 메서드 진입부에서 *내용물이 채워졌는지* require로 ` +
+                        `명시한다. 이는 시간차 invariant를 *받아들이는* 선택임을 코드에 남겨두는 것.`,
+                    tradeoffs: {
+                        pros: [
+                            "기존 호출 구조 변경 없음 (호환성 최대)",
+                            "외부에서 점진 누적이 진짜 필요한 도메인에서는 자연스러움",
+                        ],
+                        cons: [
+                            "*불완전 객체*가 코드베이스에 떠다님 — 빈 상태에서 메서드 호출 시 런타임 폭발",
+                            "테스트 fixture가 *조립 절차*를 매번 재현해야 해 testability 저하",
+                            "조영호 「객체지향의 사실과 오해」: 객체는 *항상 유효한 상태*로 살아 있어야 한다는 원칙과 충돌",
+                        ],
+                    },
+                },
+            ],
+        }));
+    }
+    return out;
+}
+//# sourceMappingURL=emptyObjectFill.js.map

package/dist/validate/emptyObjectFill.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emptyObjectFill.js","sourceRoot":"","sources":["../../src/validate/emptyObjectFill.ts"],"names":[],"mappings":"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"}

package/dist/validate/findings.d.ts

@@ -0,0 +1,22 @@
+export type Severity = "info" | "warn" | "error";
+export interface Remedy {
+    label: string;
+    summary: string;
+    tradeoffs: {
+        pros: string[];
+        cons: string[];
+    };
+}
+export interface Finding {
+    rule_id: string;
+    severity: Severity;
+    target: {
+        kind: "class" | "collaboration" | "design";
+        id: string;
+    };
+    message: string;
+    evidence: Record<string, unknown>;
+    remedies: Remedy[];
+}
+export declare function severityAtLeast(s: Severity, min: Severity): boolean;
+export declare function assertHasMultipleRemedies(f: Finding): Finding;

package/dist/validate/findings.js

@@ -0,0 +1,12 @@
+const SEVERITY_RANK = { info: 0, warn: 1, error: 2 };
+export function severityAtLeast(s, min) {
+    return SEVERITY_RANK[s] >= SEVERITY_RANK[min];
+}
+export function assertHasMultipleRemedies(f) {
+    if (f.remedies.length < 2) {
+        throw new Error(`Rule ${f.rule_id} produced a finding with fewer than 2 remedies. ` +
+            `Oh-My-OOP contract: every finding must offer at least 2 alternative remedies.`);
+    }
+    return f;
+}
+//# sourceMappingURL=findings.js.map

package/dist/validate/findings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"findings.js","sourceRoot":"","sources":["../../src/validate/findings.ts"],"names":[],"mappings":"AAiBA,MAAM,aAAa,GAA6B,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;AAE/E,MAAM,UAAU,eAAe,CAAC,CAAW,EAAE,GAAa;IACxD,OAAO,aAAa,CAAC,CAAC,CAAC,IAAI,aAAa,CAAC,GAAG,CAAC,CAAC;AAChD,CAAC;AAED,MAAM,UAAU,yBAAyB,CAAC,CAAU;IAClD,IAAI,CAAC,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC1B,MAAM,IAAI,KAAK,CACb,QAAQ,CAAC,CAAC,OAAO,kDAAkD;YACjE,+EAA+E,CAClF,CAAC;IACJ,CAAC;IACD,OAAO,CAAC,CAAC;AACX,CAAC"}

package/dist/validate/functionDecompositionExcess.d.ts

@@ -0,0 +1,3 @@
+import type { Design } from "../domain/model.js";
+import type { Finding } from "./findings.js";
+export declare function checkFunctionDecompositionExcess(design: Design): Finding[];

package/dist/validate/functionDecompositionExcess.js

@@ -0,0 +1,120 @@
+import { assertHasMultipleRemedies } from "./findings.js";
+// 한 가지 일을 *짧은 동사 함수 다수*로 쪼개는 안티패턴.
+// 대표 사례: WinningDiscriminator init을 compute/extract/build/verify/format/trim 같은
+// *도메인 명사 없는 짧은 동사*로 분해 — 의미 없는 단계 노출.
+// 근거: lotto 일반 패턴 (MCP_STRUCTURE.md §5) — "함수를 *분리*하는 것이지 *분해*하는 것이 아니다" (@krrong 류 코멘트).
+const SHORT_KOREAN_VERB = /^[가-힣]{1,5}(다|기|하기|함|이)?$/;
+const SHORT_KOREAN_NOUN = /^[가-힣]{2,4}$/;
+const SHORT_ENGLISH_VERB = /^[a-zA-Z]{2,10}$/;
+function looksLikeShortStep(doing) {
+    const t = doing.trim();
+    if (t.length === 0)
+        return true; // 빈 책임도 결국 같은 시그널
+    if (t.length > 14)
+        return false; // 충분히 길면 도메인 어휘 동반 가능
+    if (SHORT_KOREAN_VERB.test(t))
+        return true;
+    if (SHORT_KOREAN_NOUN.test(t))
+        return true;
+    if (SHORT_ENGLISH_VERB.test(t))
+        return true;
+    return false;
+}
+function hasDomainNoun(doing) {
+    const t = doing.trim();
+    // 길이가 충분히 길고 공백/조사 포함이면 도메인 어휘 가능성이 큼.
+    if (t.length > 14)
+        return true;
+    // 명백한 도메인 명사 토큰 — 영어 PascalCase 단어, 한국어 4글자 이상 명사 추정
+    if (/[A-Z][a-z]+[A-Z]/.test(t))
+        return true; // CamelCase
+    if (/[가-힣]{5,}/.test(t))
+        return true;
+    return false;
+}
+export function checkFunctionDecompositionExcess(design) {
+    const out = [];
+    for (const card of design.classes) {
+        // Interfacer는 어댑터로서 짧은 메서드 다수가 자연스러움 — 스킵.
+        if (card.stereotype === "Interfacer")
+            continue;
+        const doing = card.responsibilities.doing;
+        if (doing.length < 4)
+            continue;
+        const shortSteps = doing.filter((d) => looksLikeShortStep(d));
+        const allShort = shortSteps.length === doing.length;
+        if (!allShort)
+            continue;
+        const anyDomainNoun = doing.some((d) => hasDomainNoun(d));
+        if (anyDomainNoun)
+            continue;
+        out.push(assertHasMultipleRemedies({
+            rule_id: "function-decomposition-excess",
+            severity: "info",
+            target: { kind: "class", id: card.id },
+            message: `${card.name}의 doing 책임이 ${doing.length}개로 *짧은 동사*에 머물러 있고, 도메인 명사가 보이지 않습니다. ` +
+                `한 가지 일을 의미 없는 단계들로 *분해*했을 가능성이 있습니다. ` +
+                `함수는 *분리*되어야 하지 *분해*되어선 안 됩니다 — 각 조각이 자기 이름값을 해야 합니다.`,
+            evidence: {
+                doing_count: doing.length,
+                short_step_samples: doing.slice(0, 4),
+                guideline: "lotto 일반 가르침: \"*함수를 분리하는 것이지 분해하는 것이 아니다*\". " +
+                    "한 동작을 6개 헬퍼로 쪼개도 각 헬퍼가 도메인을 표현하지 않으면 *의미가 한 곳에 흩어지기만* 한다.",
+            },
+            remedies: [
+                {
+                    label: "도메인 어휘로 *재명명* — 단계가 아니라 의도",
+                    summary: `각 doing을 *무엇을 하는가*가 아니라 *왜 하는가*로 다시 이름 짓는다. ` +
+                        `예: extract → \"당첨 번호 추출\", verify → \"중복 없음 보장\". ` +
+                        `이름이 바뀌면 분리가 정당해지고, 정당화되지 않는 조각은 합쳐진다.`,
+                    tradeoffs: {
+                        pros: [
+                            "각 조각이 *왜 존재하는지* 코드만 봐도 드러남",
+                            "재명명 과정에서 *합쳐야 할 조각*이 자연스럽게 식별됨",
+                            "리뷰어가 \"이 단계는 왜 있죠?\"를 물을 일이 줄어듦",
+                        ],
+                        cons: [
+                            "이름 자체가 길어져 라인 폭이 늘 수 있음",
+                            "기존 호출자의 메서드명 의존이 깨질 수 있음 (검색/리네임 비용)",
+                        ],
+                    },
+                },
+                {
+                    label: "단계 *재흡수* — 한 메서드 안으로 합치기",
+                    summary: `이름값 못 하는 조각들을 한 도메인 메서드 안의 *지역 변수/표현식*으로 합친다. ` +
+                        `여러 헬퍼가 단 한 곳에서만 불린다면, 헬퍼는 *변수 하나*만큼의 가치도 못 한다.`,
+                    tradeoffs: {
+                        pros: [
+                            "*단일 사용 헬퍼* 제거로 호출 그래프 단순화",
+                            "맥락이 한 자리에 모여 *읽기 흐름*이 끊기지 않음",
+                            "테스트가 *행위 단위*로 작성되어 단계별 결합 감소",
+                        ],
+                        cons: [
+                            "메서드 한 개의 라인 수가 증가",
+                            "조각마다 단위 테스트하던 패턴이 깨짐 — 더 큰 단위 테스트가 필요",
+                        ],
+                    },
+                },
+                {
+                    label: "*진짜 협력자*로 단계를 객체화",
+                    summary: `조각 중 *2개 이상*이 한 도메인 개념(예: NumberExtractor, DuplicationGuard)을 함께 ` +
+                        `표현한다면 새 ServiceProvider로 빼서 ${card.name}의 협력자가 되게 한다. ` +
+                        `*함수 분해*가 아니라 *객체 분리*로 승격.`,
+                    tradeoffs: {
+                        pros: [
+                            "함수 다수가 *진짜 책임*을 가진 객체로 승격",
+                            "테스트 단위가 *객체 경계*로 다시 정렬됨",
+                            "OCP에 가까워짐 — 새 정책 추가가 새 객체로 가능",
+                        ],
+                        cons: [
+                            "객체 수 증가 — 통증이 적다면 과설계",
+                            "협력 그래프가 복잡해져 *호출 흐름 추적* 비용 증가",
+                        ],
+                    },
+                },
+            ],
+        }));
+    }
+    return out;
+}
+//# sourceMappingURL=functionDecompositionExcess.js.map

package/dist/validate/functionDecompositionExcess.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"functionDecompositionExcess.js","sourceRoot":"","sources":["../../src/validate/functionDecompositionExcess.ts"],"names":[],"mappings":"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"}

package/dist/validate/functionNotObject.d.ts

@@ -0,0 +1,3 @@
+import type { Design } from "../domain/model.js";
+import type { Finding } from "./findings.js";
+export declare function checkFunctionNotObject(design: Design): Finding[];

package/dist/validate/functionNotObject.js

@@ -0,0 +1,80 @@
+import { assertHasMultipleRemedies } from "./findings.js";
+// "객체는 메서드 + 멤버 둘 다" — @ghojeong (PR #128)
+// 멤버(knowing) 없이 행위(doing) 하나만 있는 클래스는 사실상 함수.
+// "judge() 함수만 가진 Winner 클래스"가 대표 사례.
+export function checkFunctionNotObject(design) {
+    const out = [];
+    for (const card of design.classes) {
+        const knowingCount = card.responsibilities.knowing.length;
+        const doingCount = card.responsibilities.doing.length;
+        // 멤버 0 + 행위 1개 → 함수에 가까움
+        // 단, Interfacer는 외부 시스템과의 어댑터로 knowing이 0일 수 있어 예외
+        if (card.stereotype === "Interfacer")
+            continue;
+        if (knowingCount > 0)
+            continue;
+        if (doingCount !== 1)
+            continue;
+        out.push(assertHasMultipleRemedies({
+            rule_id: "function-not-object",
+            severity: "info",
+            target: { kind: "class", id: card.id },
+            message: `${card.name}은(는) knowing(멤버)이 없고 doing이 1개뿐이라 사실상 *함수*에 가깝습니다. ` +
+                `객체는 메서드와 멤버 둘 다로 구성됩니다.`,
+            evidence: {
+                knowing_count: knowingCount,
+                doing_count: doingCount,
+                stereotype: card.stereotype,
+                doing_text: card.responsibilities.doing[0],
+                guideline: "@ghojeong (PR #128): \"객체는 메서드 뿐만 아니라 멤버로도 구성된다는 사실을 잊지 말아주세요.\"",
+            },
+            remedies: [
+                {
+                    label: "함수로 강등 (top-level 또는 object의 메서드)",
+                    summary: `클래스로 둘 가치가 없다면 일반 함수 또는 object 안의 함수로 옮긴다. ` +
+                        `호출자가 인스턴스화 부담에서 해방된다.`,
+                    tradeoffs: {
+                        pros: [
+                            "객체 수 감소",
+                            "호출 단순화 (인스턴스화 불필요)",
+                            "분리의 정당화가 약한 클래스 제거",
+                        ],
+                        cons: [
+                            "나중에 상태가 추가될 가능성이 있다면 다시 클래스로 되돌리는 비용",
+                        ],
+                    },
+                },
+                {
+                    label: "데이터 소유 객체에 메서드로 흡수",
+                    summary: `${card.responsibilities.doing[0]} 행위가 다루는 데이터의 소유자(예: 일급 컬렉션)에 ` +
+                        `메서드로 옮긴다. Tell-Don't-Ask 강화.`,
+                    tradeoffs: {
+                        pros: [
+                            "행위와 데이터가 한 곳에 (응집도 향상)",
+                            "기존 호출자는 더 자연스러운 메시지 사용",
+                        ],
+                        cons: [
+                            "데이터 소유 객체가 비대해질 수 있음",
+                        ],
+                    },
+                },
+                {
+                    label: "멤버를 추가해 진짜 객체로 격상",
+                    summary: `이 클래스가 *영구한 상태/정책*을 가져야 한다면 knowing을 추가한다. ` +
+                        `예: ${card.name}이 정책 객체라면 정책 파라미터(임계값 등)를 멤버로.`,
+                    tradeoffs: {
+                        pros: [
+                            "클래스로 둘 정당성이 생김",
+                            "정책 변경 시 인스턴스만 교체",
+                        ],
+                        cons: [
+                            "knowing이 사실은 *외부 의존*에 불과하다면 부자연스러운 멤버화",
+                        ],
+                    },
+                },
+            ],
+        }));
+    }
+    return out;
+}
+//# sourceMappingURL=functionNotObject.js.map

package/dist/validate/functionNotObject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"functionNotObject.js","sourceRoot":"","sources":["../../src/validate/functionNotObject.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAE1D,2CAA2C;AAC3C,+CAA+C;AAC/C,sCAAsC;AAEtC,MAAM,UAAU,sBAAsB,CAAC,MAAc;IACnD,MAAM,GAAG,GAAc,EAAE,CAAC;IAE1B,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;QAClC,MAAM,YAAY,GAAG,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,MAAM,CAAC;QAC1D,MAAM,UAAU,GAAG,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,MAAM,CAAC;QAEtD,yBAAyB;QACzB,mDAAmD;QACnD,IAAI,IAAI,CAAC,UAAU,KAAK,YAAY;YAAE,SAAS;QAC/C,IAAI,YAAY,GAAG,CAAC;YAAE,SAAS;QAC/B,IAAI,UAAU,KAAK,CAAC;YAAE,SAAS;QAE/B,GAAG,CAAC,IAAI,CACN,yBAAyB,CAAC;YACxB,OAAO,EAAE,qBAAqB;YAC9B,QAAQ,EAAE,MAAM;YAChB,MAAM,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE;YACtC,OAAO,EACL,GAAG,IAAI,CAAC,IAAI,qDAAqD;gBACjE,yBAAyB;YAC3B,QAAQ,EAAE;gBACR,aAAa,EAAE,YAAY;gBAC3B,WAAW,EAAE,UAAU;gBACvB,UAAU,EAAE,IAAI,CAAC,UAAU;gBAC3B,UAAU,EAAE,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAC;gBAC1C,SAAS,EACP,kEAAkE;aACrE;YACD,QAAQ,EAAE;gBACR;oBACE,KAAK,EAAE,mCAAmC;oBAC1C,OAAO,EACL,6CAA6C;wBAC7C,uBAAuB;oBACzB,SAAS,EAAE;wBACT,IAAI,EAAE;4BACJ,SAAS;4BACT,oBAAoB;4BACpB,oBAAoB;yBACrB;wBACD,IAAI,EAAE;4BACJ,sCAAsC;yBACvC;qBACF;iBACF;gBACD;oBACE,KAAK,EAAE,oBAAoB;oBAC3B,OAAO,EACL,GAAG,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAC,gCAAgC;wBACjE,8BAA8B;oBAChC,SAAS,EAAE;wBACT,IAAI,EAAE;4BACJ,wBAAwB;4BACxB,wBAAwB;yBACzB;wBACD,IAAI,EAAE;4BACJ,sBAAsB;yBACvB;qBACF;iBACF;gBACD;oBACE,KAAK,EAAE,mBAAmB;oBAC1B,OAAO,EACL,6CAA6C;wBAC7C,MAAM,IAAI,CAAC,IAAI,gCAAgC;oBACjD,SAAS,EAAE;wBACT,IAAI,EAAE;4BACJ,gBAAgB;4BAChB,kBAAkB;yBACnB;wBACD,IAAI,EAAE;4BACJ,wCAAwC;yBACzC;qBACF;iBACF;aACF;SACF,CAAC,CACH,CAAC;IACJ,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/validate/godObject.d.ts

@@ -0,0 +1,6 @@
+import type { Design } from "../domain/model.js";
+import type { Finding } from "./findings.js";
+export declare function checkGodObject(design: Design, thresholds: {
+    responsibilities: number;
+    collaborators: number;
+}): Finding[];

package/dist/validate/godObject.js

@@ -0,0 +1,76 @@
+import { assertHasMultipleRemedies } from "./findings.js";
+export function checkGodObject(design, thresholds) {
+    const out = [];
+    for (const card of design.classes) {
+        const total = card.responsibilities.knowing.length + card.responsibilities.doing.length;
+        const tooManyResp = total > thresholds.responsibilities;
+        const tooManyCollab = card.collaborators.length > thresholds.collaborators;
+        if (!tooManyResp && !tooManyCollab)
+            continue;
+        out.push(assertHasMultipleRemedies({
+            rule_id: "god-object",
+            severity: "warn",
+            target: { kind: "class", id: card.id },
+            message: `${card.name}이(가) ${total}개의 책임, ${card.collaborators.length}명의 협력자를 가져 ` +
+                `(${tooManyResp ? "책임 과다" : ""}${tooManyResp && tooManyCollab ? " · " : ""}${tooManyCollab ? "협력자 과다" : ""}) ` +
+                `God Object 가능성이 있습니다.`,
+            evidence: {
+                responsibilities: total,
+                collaborators: card.collaborators.length,
+                thresholds,
+                guideline: "@ghojeong (woowacourse-kotlin-blackjack kimhm0728/72): \"해당 역할을 컴퓨터가 아니라 사람에게 시키려고 했을 때, 사람이 한 명 더 필요한가 아니면 같은 사람에게 시킬 수 있을까를 고민해보세요.\" — " +
+                    "한 객체가 *여러 역할*을 가지면 사람 시뮬레이션 결과로 분리 후보. " +
+                    "변경 이유가 *둘 이상의 축*에 모이면 god-object 의 시작이다.",
+            },
+            remedies: [
+                {
+                    label: "doing 클러스터를 새 협력자로 추출",
+                    summary: "가장 응집도 높은 doing 책임 묶음을 별개 ServiceProvider로 분리하고, " +
+                        "현재 클래스는 그 협력자에게 위임한다.",
+                    tradeoffs: {
+                        pros: [
+                            "각 클래스 책임이 명확해진다",
+                            "테스트 단위가 작아진다",
+                            "변경 영향 범위가 축소된다",
+                        ],
+                        cons: [
+                            "협력자 수가 1 증가하여 결합도 측면은 트레이드오프",
+                            "추출 기준이 모호하면 인위적인 분리가 될 수 있음",
+                        ],
+                    },
+                },
+                {
+                    label: "knowing 클러스터를 값 객체(InformationHolder)로 추출",
+                    summary: "강하게 묶인 knowing 책임을 새 InformationHolder로 옮기고, " +
+                        "이 클래스는 그 값을 보유하도록 한다.",
+                    tradeoffs: {
+                        pros: [
+                            "도메인 개념이 1급으로 드러난다",
+                            "원시 타입 강박을 줄인다",
+                        ],
+                        cons: [
+                            "단순 위임이 늘어 표면적인 코드량이 증가",
+                            "값 객체가 진짜 도메인 개념이 아니면 과한 추상화",
+                        ],
+                    },
+                },
+                {
+                    label: "Coordinator/Service 분리 (역할별 분할)",
+                    summary: "흐름 조율(Coordinator)과 도메인 계산(ServiceProvider)을 다른 클래스로 분리한다.",
+                    tradeoffs: {
+                        pros: [
+                            "Stereotype 혼합을 제거해 책임이 깔끔해짐",
+                            "Tell-Don't-Ask 적용이 쉬워짐",
+                        ],
+                        cons: [
+                            "객체 수가 늘어 초기 학습 비용 증가",
+                            "유스케이스가 단순하면 과설계가 될 수 있음",
+                        ],
+                    },
+                },
+            ],
+        }));
+    }
+    return out;
+}
+//# sourceMappingURL=godObject.js.map

package/dist/validate/godObject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"godObject.js","sourceRoot":"","sources":["../../src/validate/godObject.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAE1D,MAAM,UAAU,cAAc,CAC5B,MAAc,EACd,UAA+D;IAE/D,MAAM,GAAG,GAAc,EAAE,CAAC;IAC1B,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;QAClC,MAAM,KAAK,GACT,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,MAAM,CAAC;QAC5E,MAAM,WAAW,GAAG,KAAK,GAAG,UAAU,CAAC,gBAAgB,CAAC;QACxD,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,GAAG,UAAU,CAAC,aAAa,CAAC;QAC3E,IAAI,CAAC,WAAW,IAAI,CAAC,aAAa;YAAE,SAAS;QAE7C,GAAG,CAAC,IAAI,CACN,yBAAyB,CAAC;YACxB,OAAO,EAAE,YAAY;YACrB,QAAQ,EAAE,MAAM;YAChB,MAAM,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE;YACtC,OAAO,EACL,GAAG,IAAI,CAAC,IAAI,QAAQ,KAAK,UAAU,IAAI,CAAC,aAAa,CAAC,MAAM,aAAa;gBACzE,IAAI,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,WAAW,IAAI,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,aAAa,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,IAAI;gBAC9G,uBAAuB;YACzB,QAAQ,EAAE;gBACR,gBAAgB,EAAE,KAAK;gBACvB,aAAa,EAAE,IAAI,CAAC,aAAa,CAAC,MAAM;gBACxC,UAAU;gBACV,SAAS,EACP,4IAA4I;oBAC5I,yCAAyC;oBACzC,0CAA0C;aAC7C;YACD,QAAQ,EAAE;gBACR;oBACE,KAAK,EAAE,uBAAuB;oBAC9B,OAAO,EACL,mDAAmD;wBACnD,uBAAuB;oBACzB,SAAS,EAAE;wBACT,IAAI,EAAE;4BACJ,iBAAiB;4BACjB,cAAc;4BACd,gBAAgB;yBACjB;wBACD,IAAI,EAAE;4BACJ,8BAA8B;4BAC9B,6BAA6B;yBAC9B;qBACF;iBACF;gBACD;oBACE,KAAK,EAAE,2CAA2C;oBAClD,OAAO,EACL,+CAA+C;wBAC/C,uBAAuB;oBACzB,SAAS,EAAE;wBACT,IAAI,EAAE;4BACJ,mBAAmB;4BACnB,eAAe;yBAChB;wBACD,IAAI,EAAE;4BACJ,wBAAwB;4BACxB,6BAA6B;yBAC9B;qBACF;iBACF;gBACD;oBACE,KAAK,EAAE,iCAAiC;oBACxC,OAAO,EACL,4DAA4D;oBAC9D,SAAS,EAAE;wBACT,IAAI,EAAE;4BACJ,6BAA6B;4BAC7B,wBAAwB;yBACzB;wBACD,IAAI,EAAE;4BACJ,sBAAsB;4BACtB,yBAAyB;yBAC1B;qBACF;iBACF;aACF;SACF,CAAC,CACH,CAAC;IACJ,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/validate/presentationInDomain.d.ts

@@ -0,0 +1,3 @@
+import type { Design } from "../domain/model.js";
+import type { Finding } from "./findings.js";
+export declare function checkPresentationInDomain(design: Design): Finding[];

package/dist/validate/presentationInDomain.js

@@ -0,0 +1,57 @@
+import { assertHasMultipleRemedies } from "./findings.js";
+// 계층 누수(presentation-in-domain): 도메인 stereotype(비-Interfacer)이 표현/출력 책임을 가짐.
+// 예) InformationHolder가 자기 상태를 표시 문자열로 포맷(toString/getStatus류).
+// 표현 형식 결정은 Interfacer(View)의 자리다 (Wirfs-Brock stereotype, 조영호).
+// 도메인이 표시 문자열을 만들면 출력 형식이 바뀔 때 도메인이 오염된다.
+//
+// 주의: 설계 모델의 *책임 문구*에 대한 휴리스틱이다(코드 파싱 아님) → 권고(warn), 오탐 가능.
+const PRESENTATION_RE = /(출력|화면|콘솔|포맷|렌더|문자열로\s*(표현|표시|변환|만든)|표시한다|toString|\bprint|\brender|\bformat|\bdisplay)/i;
+export function checkPresentationInDomain(design) {
+    const out = [];
+    for (const card of design.classes) {
+        // 표현은 Interfacer의 정당한 책임 → 면제
+        if (card.stereotype === "Interfacer")
+            continue;
+        const offenders = card.responsibilities.doing.filter((d) => PRESENTATION_RE.test(d));
+        if (offenders.length === 0)
+            continue;
+        out.push(assertHasMultipleRemedies({
+            rule_id: "presentation-in-domain",
+            severity: "warn",
+            target: { kind: "class", id: card.id },
+            message: `${card.name}(${card.stereotype})이(가) 표현/출력 책임(${offenders
+                .map((o) => `"${o}"`)
+                .join(", ")})을 가집니다. ` +
+                `표현 형식 결정은 Interfacer(View)의 자리입니다 — 도메인 객체가 표시 문자열을 만들면 출력 형식 변경이 도메인을 오염시킵니다.`,
+            evidence: { stereotype: card.stereotype, offending_responsibilities: offenders },
+            remedies: [
+                {
+                    label: "표현 책임을 Interfacer로 이전",
+                    summary: "표시 형식 결정을 View/OutputView 같은 Interfacer로 옮기고, 도메인은 값/상태만 노출한다.",
+                    tradeoffs: {
+                        pros: ["출력 형식 변경이 도메인을 건드리지 않는다", "도메인이 순수해져 단위 테스트가 쉽다"],
+                        cons: ["뷰가 도메인 값을 읽게 되어 약한 노출이 생긴다"],
+                    },
+                },
+                {
+                    label: "표시용 값 객체를 반환",
+                    summary: "포맷된 문자열 대신 구조화된 표시용 값(예: 이름+위치)을 반환하고, 포맷은 호출측(뷰)이 결정한다.",
+                    tradeoffs: {
+                        pros: ["뷰가 도메인 내부가 아니라 명시적 계약에 의존한다", "도메인 내부 리팩터링에 강하다"],
+                        cons: ["표시용 타입이 하나 늘어난다"],
+                    },
+                },
+                {
+                    label: "단순 케이스면 의도를 명시하고 유지",
+                    summary: "출력 형식이 사소하고 변하지 않는다면 notes에 사유를 적고 유지한다.",
+                    tradeoffs: {
+                        pros: ["작은 미션에 실용적이다", "객체 수가 최소화된다"],
+                        cons: ["형식 변경 시 도메인 수정이 필요하다", "stereotype 경계가 흐려진다"],
+                    },
+                },
+            ],
+        }));
+    }
+    return out;
+}
+//# sourceMappingURL=presentationInDomain.js.map

package/dist/validate/presentationInDomain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"presentationInDomain.js","sourceRoot":"","sources":["../../src/validate/presentationInDomain.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAE1D,6EAA6E;AAC7E,gEAAgE;AAChE,iEAAiE;AACjE,0CAA0C;AAC1C,EAAE;AACF,6DAA6D;AAC7D,MAAM,eAAe,GACnB,0FAA0F,CAAC;AAE7F,MAAM,UAAU,yBAAyB,CAAC,MAAc;IACtD,MAAM,GAAG,GAAc,EAAE,CAAC;IAC1B,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;QAClC,8BAA8B;QAC9B,IAAI,IAAI,CAAC,UAAU,KAAK,YAAY;YAAE,SAAS;QAC/C,MAAM,SAAS,GAAG,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QACrF,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC;YAAE,SAAS;QACrC,GAAG,CAAC,IAAI,CACN,yBAAyB,CAAC;YACxB,OAAO,EAAE,wBAAwB;YACjC,QAAQ,EAAE,MAAM;YAChB,MAAM,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE;YACtC,OAAO,EACL,GAAG,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,UAAU,kBAAkB,SAAS;iBACvD,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC;iBACpB,IAAI,CAAC,IAAI,CAAC,WAAW;gBACxB,gFAAgF;YAClF,QAAQ,EAAE,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,0BAA0B,EAAE,SAAS,EAAE;YAChF,QAAQ,EAAE;gBACR;oBACE,KAAK,EAAE,uBAAuB;oBAC9B,OAAO,EACL,gEAAgE;oBAClE,SAAS,EAAE;wBACT,IAAI,EAAE,CAAC,yBAAyB,EAAE,sBAAsB,CAAC;wBACzD,IAAI,EAAE,CAAC,4BAA4B,CAAC;qBACrC;iBACF;gBACD;oBACE,KAAK,EAAE,cAAc;oBACrB,OAAO,EACL,0DAA0D;oBAC5D,SAAS,EAAE;wBACT,IAAI,EAAE,CAAC,6BAA6B,EAAE,kBAAkB,CAAC;wBACzD,IAAI,EAAE,CAAC,iBAAiB,CAAC;qBAC1B;iBACF;gBACD;oBACE,KAAK,EAAE,qBAAqB;oBAC5B,OAAO,EAAE,0CAA0C;oBACnD,SAAS,EAAE;wBACT,IAAI,EAAE,CAAC,cAAc,EAAE,aAAa,CAAC;wBACrC,IAAI,EAAE,CAAC,sBAAsB,EAAE,qBAAqB,CAAC;qBACtD;iBACF;aACF;SACF,CAAC,CACH,CAAC;IACJ,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/validate/primitiveWrapper.d.ts

@@ -0,0 +1,3 @@
+import type { Design } from "../domain/model.js";
+import type { Finding } from "./findings.js";
+export declare function checkPrimitiveWrapperWithoutInvariant(design: Design): Finding[];