oh-my-oop 0.2.0

package/dist/tradeoff/heuristics/strategyOrPolicy.js

@@ -0,0 +1,110 @@
+// "정책/전략을 *interface로* 풀까 *enum*으로 풀까" — Kotlin 도메인의 빈번한 결정.
+// 근거: lotto PR #131, #144, #147 (LottoMachine/LottoRank/등급 결정).
+export function strategyOrPolicySeeds(targetName) {
+    const T = targetName || "Decision";
+    return [
+        {
+            id: "sp-interface",
+            label: "Strategy interface + 구현체",
+            summary: `${T}을 인터페이스로 선언하고 구현체를 주입한다. 각 구현체는 *자기 상태/의존*을 ` +
+                `생성자로 받는다 (예: ManualLottoMachine(numbers), AutomaticLottoMachine(random)).`,
+            design_delta: {
+                added_classes: [{ name: `${T}Strategy`, stereotype: "ServiceProvider" }],
+            },
+            tradeoffs: {
+                pros: [
+                    "구현체별 *자기 상태*를 생성자로 받아 인터페이스 시그니처를 정화",
+                    "테스트에서 *페이크 구현체* 주입 용이 (Random/Clock 같은 non-newable 분리)",
+                    "새 정책 추가가 *새 클래스 추가*로 끝남 (OCP에 가까움)",
+                ],
+                cons: [
+                    "구현체별 *생성/주입* 책임이 호출 지점에 분산",
+                    "정책이 1~2종에서 끝나면 *과설계*",
+                    "*케이스 추가의 폐쇄성*이 깨질 수 있음 — sealed가 아니라면 컴파일러가 누락 케이스를 알려주지 못함",
+                ],
+            },
+            cho_younghos_lens: {
+                cohesion: "improves",
+                coupling: "improves",
+                testability: "improves",
+                notes: "*다형성으로 정책을 표현*하는 가장 객체지향적인 선택.",
+            },
+        },
+        {
+            id: "sp-enum-policy",
+            label: "enum class + 케이스별 동작",
+            summary: `${T}을 enum으로 정의하고 각 상수가 자기 데이터를 가지거나 추상 메서드를 오버라이드한다. ` +
+                `예: enum class Rank(val matchCount: Int, val money: Long) { FIRST(6, ...), SECOND(5, ...) }`,
+            design_delta: {},
+            tradeoffs: {
+                pros: [
+                    "케이스가 *닫혀 있음*이 타입에 드러나 when exhaustive 보장",
+                    "각 케이스의 *영구한 도메인 데이터*가 한 자리에 모임",
+                    "*수가 적고 변하지 않는* 정책에 가벼움",
+                ],
+                cons: [
+                    "케이스마다 의존 주입 어려움 — 생성자가 *정적 데이터*에 한정",
+                    "*동작이 외부 상태에 의존*해야 하면 enum이 깨지기 시작",
+                    "ordinal 기반 코드 결합 위험 (\"첫 번째 enum이 0등\" 같은 암묵적 가정)",
+                ],
+            },
+            cho_younghos_lens: {
+                cohesion: "improves",
+                coupling: "neutral",
+                testability: "neutral",
+                notes: "lotto Rank처럼 *고정 도메인 사실*을 표현할 때 자연. 외부 의존이 끼면 interface로 전환 신호.",
+            },
+        },
+        {
+            id: "sp-sealed-class",
+            label: "sealed class + when 분기",
+            summary: `${T}을 sealed class(또는 sealed interface)로 만들어 *닫힌 다형성*을 표현. ` +
+                `케이스마다 *서로 다른 필드*를 가질 수 있어 enum의 한계를 보완.`,
+            design_delta: {},
+            tradeoffs: {
+                pros: [
+                    "케이스별 *서로 다른 데이터 모양*을 자연스럽게 표현 (Manual(numbers) vs Automatic)",
+                    "when 표현식이 *모든 케이스를 컴파일 단계에서* 강제 — 누락 차단",
+                    "enum 대비 *상속/생성자 자유도* 확보",
+                ],
+                cons: [
+                    "변형 추가가 모든 when 분기 수정 비용 유발 (OCP 약화)",
+                    "when 분기가 코드 곳곳에 흩어지면 *추상화 누설*",
+                    "외부 의존 주입은 여전히 *생성자 의존*",
+                ],
+            },
+            cho_younghos_lens: {
+                cohesion: "improves",
+                coupling: "neutral",
+                testability: "improves",
+                notes: "다형성과 enum의 *중간 지점*. 변형 데이터 모양이 다를 때 선택.",
+            },
+        },
+        {
+            id: "sp-functional",
+            label: "함수 타입(고차 함수) 정책",
+            summary: `${T}을 별도 객체 없이 \`(Input) -> Output\` 함수 타입으로 주입한다. ` +
+                `간단한 정책(예: random 선택 함수)에 가장 가벼움.`,
+            design_delta: {},
+            tradeoffs: {
+                pros: [
+                    "*케이스 추가 = 람다 작성*으로 최소 비용",
+                    "테스트에서 *람다 stub*으로 매우 간결",
+                    "*Random/Clock* 같은 외부 의존 분리에 자연 (Kotlin functional interface)",
+                ],
+                cons: [
+                    "함수 시그니처만 봐서는 *의도*가 코드에 드러나지 않음",
+                    "*명명되지 않은 정책*이 호출 그래프에 떠다니면 디버깅 비용 증가",
+                    "정책 수가 늘면 다시 객체화가 필요 — 마이그레이션 비용",
+                ],
+            },
+            cho_younghos_lens: {
+                cohesion: "neutral",
+                coupling: "improves",
+                testability: "improves",
+                notes: "정책이 *얇고 일회성*일 때 자연. 본격 도메인이 되면 객체로 승격 신호.",
+            },
+        },
+    ];
+}
+//# sourceMappingURL=strategyOrPolicy.js.map

package/dist/tradeoff/heuristics/strategyOrPolicy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategyOrPolicy.js","sourceRoot":"","sources":["../../../src/tradeoff/heuristics/strategyOrPolicy.ts"],"names":[],"mappings":"AAEA,6DAA6D;AAC7D,gEAAgE;AAEhE,MAAM,UAAU,qBAAqB,CAAC,UAAkB;IACtD,MAAM,CAAC,GAAG,UAAU,IAAI,UAAU,CAAC;IACnC,OAAO;QACL;YACE,EAAE,EAAE,cAAc;YAClB,KAAK,EAAE,0BAA0B;YACjC,OAAO,EACL,GAAG,CAAC,8CAA8C;gBAClD,2EAA2E;YAC7E,YAAY,EAAE;gBACZ,aAAa,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,UAAU,EAAE,UAAU,EAAE,iBAAiB,EAAE,CAAC;aACzE;YACD,SAAS,EAAE;gBACT,IAAI,EAAE;oBACJ,sCAAsC;oBACtC,wDAAwD;oBACxD,oCAAoC;iBACrC;gBACD,IAAI,EAAE;oBACJ,4BAA4B;oBAC5B,sBAAsB;oBACtB,6DAA6D;iBAC9D;aACF;YACD,iBAAiB,EAAE;gBACjB,QAAQ,EAAE,UAAU;gBACpB,QAAQ,EAAE,UAAU;gBACpB,WAAW,EAAE,UAAU;gBACvB,KAAK,EAAE,gCAAgC;aACxC;SACF;QACD;YACE,EAAE,EAAE,gBAAgB;YACpB,KAAK,EAAE,sBAAsB;YAC7B,OAAO,EACL,GAAG,CAAC,oDAAoD;gBACxD,4FAA4F;YAC9F,YAAY,EAAE,EAAE;YAChB,SAAS,EAAE;gBACT,IAAI,EAAE;oBACJ,0CAA0C;oBAC1C,gCAAgC;oBAChC,wBAAwB;iBACzB;gBACD,IAAI,EAAE;oBACJ,qCAAqC;oBACrC,mCAAmC;oBACnC,mDAAmD;iBACpD;aACF;YACD,iBAAiB,EAAE;gBACjB,QAAQ,EAAE,UAAU;gBACpB,QAAQ,EAAE,SAAS;gBACnB,WAAW,EAAE,SAAS;gBACtB,KAAK,EAAE,iEAAiE;aACzE;SACF;QACD;YACE,EAAE,EAAE,iBAAiB;YACrB,KAAK,EAAE,wBAAwB;YAC/B,OAAO,EACL,GAAG,CAAC,yDAAyD;gBAC7D,yCAAyC;YAC3C,YAAY,EAAE,EAAE;YAChB,SAAS,EAAE;gBACT,IAAI,EAAE;oBACJ,8DAA8D;oBAC9D,yCAAyC;oBACzC,yBAAyB;iBAC1B;gBACD,IAAI,EAAE;oBACJ,qCAAqC;oBACrC,+BAA+B;oBAC/B,wBAAwB;iBACzB;aACF;YACD,iBAAiB,EAAE;gBACjB,QAAQ,EAAE,UAAU;gBACpB,QAAQ,EAAE,SAAS;gBACnB,WAAW,EAAE,UAAU;gBACvB,KAAK,EAAE,yCAAyC;aACjD;SACF;QACD;YACE,EAAE,EAAE,eAAe;YACnB,KAAK,EAAE,iBAAiB;YACxB,OAAO,EACL,GAAG,CAAC,iDAAiD;gBACrD,kCAAkC;YACpC,YAAY,EAAE,EAAE;YAChB,SAAS,EAAE;gBACT,IAAI,EAAE;oBACJ,0BAA0B;oBAC1B,yBAAyB;oBACzB,8DAA8D;iBAC/D;gBACD,IAAI,EAAE;oBACJ,gCAAgC;oBAChC,sCAAsC;oBACtC,iCAAiC;iBAClC;aACF;YACD,iBAAiB,EAAE;gBACjB,QAAQ,EAAE,SAAS;gBACnB,QAAQ,EAAE,UAAU;gBACpB,WAAW,EAAE,UAAU;gBACvB,KAAK,EAAE,2CAA2C;aACnD;SACF;KACF,CAAC;AACJ,CAAC"}

package/dist/tradeoff/heuristics/valueObjectShape.d.ts

@@ -0,0 +1,2 @@
+import type { AlternativeSeed } from "../engine.js";
+export declare function valueObjectShapeSeeds(targetName: string): AlternativeSeed[];

package/dist/tradeoff/heuristics/valueObjectShape.js

@@ -0,0 +1,111 @@
+// "값 객체를 어떤 *모양*으로 만들 것인가" — Kotlin 도메인에서 자주 보이는 결정.
+// 근거: lotto PR #8, #40, #49, #64, #75, #87, #131 (LottoNumber/Money/Profit/Rank 등).
+export function valueObjectShapeSeeds(targetName) {
+    const T = targetName || "Value";
+    return [
+        {
+            id: "vo-value-class",
+            label: "value class",
+            summary: `${T}을 \`value class\`로 선언한다. 컴파일러가 인라이닝해 원시값 수준 비용을 유지하면서, ` +
+                `타입 안전성과 init invariant를 모두 얻는다.`,
+            design_delta: {},
+            tradeoffs: {
+                pros: [
+                    "원시값 수준의 런타임 비용 (래퍼 할당 회피)",
+                    "Int/Long과 컴파일러 단계에서 구분되어 인자 순서 실수 차단",
+                    "init require로 *유효한 값만 존재* 보장",
+                    "*고빈도 생성* 도메인(LottoNumber 등)에 특히 유리",
+                ],
+                cons: [
+                    "value class 제약: secondary constructor 불가, equals/hashCode 커스터마이즈 제한",
+                    "nullable/제네릭/list 안에 들어가면 *박싱* 발생 (인라이닝 깨짐)",
+                    "필드가 *정확히 하나*여야 함 — 복합 값에는 부적합",
+                    "리플렉션/직렬화 라이브러리와의 호환성 검증 필요",
+                ],
+            },
+            cho_younghos_lens: {
+                cohesion: "improves",
+                coupling: "improves",
+                testability: "improves",
+                notes: "단일 필드 + invariant가 본질인 값 객체에 가장 정직한 모양.",
+            },
+        },
+        {
+            id: "vo-data-class",
+            label: "data class",
+            summary: `${T}을 \`data class\`로 선언한다. equals/hashCode/toString/copy/구조 분해를 자동 생성하며 ` +
+                `여러 필드를 자연스럽게 표현한다.`,
+            design_delta: {},
+            tradeoffs: {
+                pros: [
+                    "*여러 필드*로 구성된 값 객체에 적합 (Money(amount, currency) 같은)",
+                    "copy()로 변경된 사본 생성 — 불변성 유지가 쉬움",
+                    "equals/hashCode가 *값 기반*으로 자동 — 컬렉션 사용 안전",
+                    "구조 분해 선언으로 호출 측 코드 간결화",
+                ],
+                cons: [
+                    "단일 원시 필드에는 *과한 비용* — value class 대비 인스턴스 할당 비용",
+                    "*copy()의 invariant 우회* 위험 — copy는 init 호출하지만 호출자가 검증 의도를 깨기 쉬움",
+                    "data class를 *상속*하면 equals가 깨질 수 있음 (final 클래스로 두는 게 안전)",
+                ],
+            },
+            cho_younghos_lens: {
+                cohesion: "improves",
+                coupling: "neutral",
+                testability: "improves",
+                notes: "필드가 2개 이상이거나 destructuring/copy가 자주 쓰일 때 정당.",
+            },
+        },
+        {
+            id: "vo-class-with-init",
+            label: "일반 class + init require",
+            summary: `${T}을 일반 \`class\`로 선언하고 init 블록에서 invariant를 강제한다. ` +
+                `생성자 가시성을 \`private\`으로 두고 팩토리 메서드로 *입력 변환*을 분리.`,
+            design_delta: {},
+            tradeoffs: {
+                pros: [
+                    "private constructor + factory 패턴으로 *생성 정책*과 *invariant 검증*을 분리",
+                    "value/data class 제약(필드 1개, 상속 불가 등)에 묶이지 않음",
+                    "복잡한 invariant(예: 1..45 AND 짝수) 표현 자유도 가장 높음",
+                ],
+                cons: [
+                    "보일러플레이트 — equals/hashCode/toString 직접 작성",
+                    "*값 비교* 의미를 코드에 명시하지 않으면 자칫 *참조 비교*로 회귀",
+                    "리뷰어가 \"왜 data class가 아니죠?\"를 반복 질문",
+                ],
+            },
+            cho_younghos_lens: {
+                cohesion: "neutral",
+                coupling: "neutral",
+                testability: "neutral",
+                notes: "값 객체 의미를 *명시적으로 표현*해야 가치를 회복.",
+            },
+        },
+        {
+            id: "vo-keep-primitive",
+            label: "원시값 유지 + 검증을 호출 지점에 분산",
+            summary: `${T}을 별도 클래스로 만들지 않고 Int/String 등을 그대로 쓰며, 검증은 *진짜 도메인 객체*가 ` +
+                `생성 시점에 한다. 일종의 *Primitive Obsession 수용*.`,
+            design_delta: {},
+            tradeoffs: {
+                pros: [
+                    "객체 수 최소화 — 단순 도메인에 가벼움",
+                    "Kotlin 산술/비교 연산을 그대로 활용",
+                    "*검증이 정말 한 자리*에서만 일어난다면 합리적 선택",
+                ],
+                cons: [
+                    "도메인 어휘 상실 — Int 한 자리에서 \"번호인지 금액인지\" 의미가 사라짐",
+                    "*같은 검증이 여러 곳에 흩어지면* 누락이 사일런트 버그",
+                    "인자 순서 실수에 취약 (`fun foo(a: Int, b: Int)`)",
+                ],
+            },
+            cho_younghos_lens: {
+                cohesion: "neutral",
+                coupling: "hurts",
+                testability: "neutral",
+                notes: "조영호 「오브젝트」: 도메인 개념이 *코드에 직접 보이지 않으면* 협업이 어려워진다.",
+            },
+        },
+    ];
+}
+//# sourceMappingURL=valueObjectShape.js.map

package/dist/tradeoff/heuristics/valueObjectShape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueObjectShape.js","sourceRoot":"","sources":["../../../src/tradeoff/heuristics/valueObjectShape.ts"],"names":[],"mappings":"AAEA,qDAAqD;AACrD,oFAAoF;AAEpF,MAAM,UAAU,qBAAqB,CAAC,UAAkB;IACtD,MAAM,CAAC,GAAG,UAAU,IAAI,OAAO,CAAC;IAChC,OAAO;QACL;YACE,EAAE,EAAE,gBAAgB;YACpB,KAAK,EAAE,aAAa;YACpB,OAAO,EACL,GAAG,CAAC,yDAAyD;gBAC7D,iCAAiC;YACnC,YAAY,EAAE,EAAE;YAChB,SAAS,EAAE;gBACT,IAAI,EAAE;oBACJ,2BAA2B;oBAC3B,sCAAsC;oBACtC,8BAA8B;oBAC9B,oCAAoC;iBACrC;gBACD,IAAI,EAAE;oBACJ,qEAAqE;oBACrE,6CAA6C;oBAC7C,+BAA+B;oBAC/B,4BAA4B;iBAC7B;aACF;YACD,iBAAiB,EAAE;gBACjB,QAAQ,EAAE,UAAU;gBACpB,QAAQ,EAAE,UAAU;gBACpB,WAAW,EAAE,UAAU;gBACvB,KAAK,EAAE,yCAAyC;aACjD;SACF;QACD;YACE,EAAE,EAAE,eAAe;YACnB,KAAK,EAAE,YAAY;YACnB,OAAO,EACL,GAAG,CAAC,uEAAuE;gBAC3E,oBAAoB;YACtB,YAAY,EAAE,EAAE;YAChB,SAAS,EAAE;gBACT,IAAI,EAAE;oBACJ,oDAAoD;oBACpD,gCAAgC;oBAChC,0CAA0C;oBAC1C,wBAAwB;iBACzB;gBACD,IAAI,EAAE;oBACJ,gDAAgD;oBAChD,gEAAgE;oBAChE,yDAAyD;iBAC1D;aACF;YACD,iBAAiB,EAAE;gBACjB,QAAQ,EAAE,UAAU;gBACpB,QAAQ,EAAE,SAAS;gBACnB,WAAW,EAAE,UAAU;gBACvB,KAAK,EAAE,8CAA8C;aACtD;SACF;QACD;YACE,EAAE,EAAE,oBAAoB;YACxB,KAAK,EAAE,yBAAyB;YAChC,OAAO,EACL,GAAG,CAAC,kDAAkD;gBACtD,iDAAiD;YACnD,YAAY,EAAE,EAAE;YAChB,SAAS,EAAE;gBACT,IAAI,EAAE;oBACJ,gEAAgE;oBAChE,6CAA6C;oBAC7C,6CAA6C;iBAC9C;gBACD,IAAI,EAAE;oBACJ,0CAA0C;oBAC1C,wCAAwC;oBACxC,oCAAoC;iBACrC;aACF;YACD,iBAAiB,EAAE;gBACjB,QAAQ,EAAE,SAAS;gBACnB,QAAQ,EAAE,SAAS;gBACnB,WAAW,EAAE,SAAS;gBACtB,KAAK,EAAE,+BAA+B;aACvC;SACF;QACD;YACE,EAAE,EAAE,mBAAmB;YACvB,KAAK,EAAE,wBAAwB;YAC/B,OAAO,EACL,GAAG,CAAC,0DAA0D;gBAC9D,0CAA0C;YAC5C,YAAY,EAAE,EAAE;YAChB,SAAS,EAAE;gBACT,IAAI,EAAE;oBACJ,wBAAwB;oBACxB,yBAAyB;oBACzB,+BAA+B;iBAChC;gBACD,IAAI,EAAE;oBACJ,8CAA8C;oBAC9C,iCAAiC;oBACjC,0CAA0C;iBAC3C;aACF;YACD,iBAAiB,EAAE;gBACjB,QAAQ,EAAE,SAAS;gBACnB,QAAQ,EAAE,OAAO;gBACjB,WAAW,EAAE,SAAS;gBACtB,KAAK,EAAE,iDAAiD;aACzD;SACF;KACF,CAAC;AACJ,CAAC"}

package/dist/tradeoff/templates.d.ts

@@ -0,0 +1,2 @@
+export declare function expansionPromptResponsibilities(useCaseTitle: string): string;
+export declare function expansionPromptAlternatives(question: string, description: string): string;

package/dist/tradeoff/templates.js

@@ -0,0 +1,33 @@
+export function expansionPromptResponsibilities(useCaseTitle) {
+    return [
+        `# 책임 분해 풍부화 요청`,
+        ``,
+        `유스케이스 "${useCaseTitle}"에 대해 아래 시드 대안들을 받았습니다.`,
+        `각 대안에 대해 **현재 프로젝트의 도메인 어휘**를 사용해 다음을 보강해주세요:`,
+        ``,
+        `1. \`tradeoffs.pros\` / \`tradeoffs.cons\`를 추상적 문장이 아닌 이 도메인의 구체적 결과로 다시 쓰세요.`,
+        `2. \`assignments[].candidate_class\` 이름이 도메인 명사를 반영하는지 검토해 더 적절한 이름을 제안하세요.`,
+        `3. 빠진 시각이 있으면 대안을 1~2개 더 추가하세요 (총 5개를 넘기지 마세요).`,
+        `4. 조영호님 렌즈로 한 줄 평을 덧붙이세요 — "이 대안은 Tell-Don't-Ask 측면에서 ...".`,
+        ``,
+        `**중요:** 단일 권장안을 내놓지 마세요. 사용자가 선택할 수 있도록 모든 대안의 가치를 동등하게 제시하세요.`,
+    ].join("\n");
+}
+export function expansionPromptAlternatives(question, description) {
+    return [
+        `# 트레이드오프 대안 풍부화 요청`,
+        ``,
+        `질문 종류: \`${question}\``,
+        `상황: ${description}`,
+        ``,
+        `시드로 받은 대안들에 대해 다음을 수행하세요:`,
+        ``,
+        `1. 각 대안의 \`pros\`/\`cons\`를 이 프로젝트의 실제 컨텍스트로 다시 작성.`,
+        `2. \`cho_younghos_lens\`의 \`notes\`에 cohesion/coupling/testability 변화 이유를 한 문장으로 적기.`,
+        `3. 빠진 대안이 있다면 1~2개 추가 (총 5개 한도).`,
+        `4. 사용자에게 **결정을 강요하지 말고** 각 대안이 어떤 상황에서 적합한지를 분명히 하세요.`,
+        ``,
+        `결정은 사용자가 합니다. 당신의 역할은 트레이드오프를 명료하게 만드는 것입니다.`,
+    ].join("\n");
+}
+//# sourceMappingURL=templates.js.map

package/dist/tradeoff/templates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates.js","sourceRoot":"","sources":["../../src/tradeoff/templates.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,+BAA+B,CAAC,YAAoB;IAClE,OAAO;QACL,gBAAgB;QAChB,EAAE;QACF,UAAU,YAAY,yBAAyB;QAC/C,+CAA+C;QAC/C,EAAE;QACF,+EAA+E;QAC/E,6EAA6E;QAC7E,iDAAiD;QACjD,6DAA6D;QAC7D,EAAE;QACF,gEAAgE;KACjE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC;AAED,MAAM,UAAU,2BAA2B,CAAC,QAAgB,EAAE,WAAmB;IAC/E,OAAO;QACL,oBAAoB;QACpB,EAAE;QACF,YAAY,QAAQ,IAAI;QACxB,OAAO,WAAW,EAAE;QACpB,EAAE;QACF,2BAA2B;QAC3B,EAAE;QACF,qDAAqD;QACrD,sFAAsF;QACtF,kCAAkC;QAClC,uDAAuD;QACvD,EAAE;QACF,8CAA8C;KAC/C,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC"}

package/dist/util/log.d.ts

@@ -0,0 +1 @@
+export declare function logErr(...args: unknown[]): void;

package/dist/util/log.js

@@ -0,0 +1,7 @@
+export function logErr(...args) {
+    const msg = args
+        .map((a) => (typeof a === "string" ? a : JSON.stringify(a)))
+        .join(" ");
+    process.stderr.write(`[oh-my-oop] ${msg}\n`);
+}
+//# sourceMappingURL=log.js.map

package/dist/util/log.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.js","sourceRoot":"","sources":["../../src/util/log.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,MAAM,CAAC,GAAG,IAAe;IACvC,MAAM,GAAG,GAAG,IAAI;SACb,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;SAC3D,IAAI,CAAC,GAAG,CAAC,CAAC;IACb,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC;AAC/C,CAAC"}

package/dist/util/mcp.d.ts

@@ -0,0 +1,4 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+export declare function jsonResult(data: unknown, text?: string): CallToolResult;
+export declare function textResult(text: string): CallToolResult;
+export declare function errorResult(message: string): CallToolResult;

package/dist/util/mcp.js

@@ -0,0 +1,18 @@
+export function jsonResult(data, text) {
+    const json = JSON.stringify(data, null, 2);
+    const blocks = [];
+    if (text)
+        blocks.push({ type: "text", text });
+    blocks.push({ type: "text", text: "```json\n" + json + "\n```" });
+    return { content: blocks, structuredContent: data };
+}
+export function textResult(text) {
+    return { content: [{ type: "text", text }] };
+}
+export function errorResult(message) {
+    return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        isError: true,
+    };
+}
+//# sourceMappingURL=mcp.js.map

package/dist/util/mcp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.js","sourceRoot":"","sources":["../../src/util/mcp.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,UAAU,CAAC,IAAa,EAAE,IAAa;IACrD,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;IAC3C,MAAM,MAAM,GAA8B,EAAE,CAAC;IAC7C,IAAI,IAAI;QAAE,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;IAC9C,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,OAAO,EAAE,CAAC,CAAC;IAClE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,IAA+B,EAAE,CAAC;AACjF,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,IAAY;IACrC,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC;AAC/C,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,OAAe;IACzC,OAAO;QACL,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,OAAO,EAAE,EAAE,CAAC;QACtD,OAAO,EAAE,IAAI;KACd,CAAC;AACJ,CAAC"}

package/dist/validate/cohesion.d.ts

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

package/dist/validate/cohesion.js

@@ -0,0 +1,88 @@
+import { assertHasMultipleRemedies } from "./findings.js";
+const STOPWORDS = new Set([
+    "을",
+    "를",
+    "이",
+    "가",
+    "은",
+    "는",
+    "에",
+    "와",
+    "과",
+    "의",
+    "한다",
+    "안다",
+    "한",
+    "the",
+    "a",
+    "an",
+    "of",
+    "and",
+    "or",
+    "to",
+]);
+function tokens(text) {
+    return new Set(text
+        .toLowerCase()
+        .replace(/[()\[\]{}.,;:!?]/g, " ")
+        .split(/\s+/)
+        .map((t) => t.trim())
+        .filter((t) => t.length > 1 && !STOPWORDS.has(t)));
+}
+function overlap(a, b) {
+    if (a.size === 0 || b.size === 0)
+        return 0;
+    let inter = 0;
+    for (const t of a)
+        if (b.has(t))
+            inter++;
+    return inter / Math.min(a.size, b.size);
+}
+export function checkCohesion(design, threshold) {
+    const out = [];
+    for (const card of design.classes) {
+        const knowingText = card.responsibilities.knowing.join(" ");
+        const doingText = card.responsibilities.doing.join(" ");
+        if (!knowingText || !doingText)
+            continue;
+        const score = overlap(tokens(knowingText), tokens(doingText));
+        if (score >= threshold)
+            continue;
+        out.push(assertHasMultipleRemedies({
+            rule_id: "low-cohesion",
+            severity: "info",
+            target: { kind: "class", id: card.id },
+            message: `${card.name}의 knowing과 doing 책임 간 어휘 중복도가 ${(score * 100).toFixed(0)}%로 낮아 ` +
+                `책임들이 같은 클래스에 모인 근거가 약합니다.`,
+            evidence: { overlap: score, threshold },
+            remedies: [
+                {
+                    label: "고립된 knowing을 별개 클래스로 분리",
+                    summary: "doing에서 사용되지 않는 knowing을 별개 InformationHolder로 옮긴다.",
+                    tradeoffs: {
+                        pros: ["응집도가 명확해진다", "각 클래스가 한 가지 이유로만 변경된다"],
+                        cons: ["클래스 수가 늘어난다"],
+                    },
+                },
+                {
+                    label: "doing 책임을 추가하여 knowing 사용처를 확보",
+                    summary: "knowing이 의도된 것이라면 그것을 활용하는 doing을 명시한다.",
+                    tradeoffs: {
+                        pros: ["기존 구조 유지", "도메인 의도가 코드로 드러남"],
+                        cons: ["의미 없는 책임을 억지로 만들 위험"],
+                    },
+                },
+                {
+                    label: "사용되지 않는 knowing을 제거",
+                    summary: "정말로 쓰이지 않는 데이터라면 삭제한다.",
+                    tradeoffs: {
+                        pros: ["YAGNI 위배 해소", "단순해짐"],
+                        cons: ["미래 요구를 잘못 추측한 경우 재추가 비용"],
+                    },
+                },
+            ],
+        }));
+    }
+    return out;
+}
+//# sourceMappingURL=cohesion.js.map

package/dist/validate/cohesion.js.map

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

package/dist/validate/collectionWrapper.d.ts

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

package/dist/validate/collectionWrapper.js

@@ -0,0 +1,131 @@
+import { assertHasMultipleRemedies } from "./findings.js";
+// 일급 컬렉션을 만들었지만 *List를 감싸는 것 외에 아무 역할이 없는* 안티패턴.
+// 대표 사례: class Lottos(val list: List<Lotto>)만 두고 도메인 메서드 없음.
+// woowacourse/kotlin-lotto PR #144 (jiyuneel) — 학생 자가 답변과 @krrong 균형 코멘트.
+const PASS_THROUGH_VERBS = [
+    // 표현/직렬화
+    "tostring",
+    "tolines",
+    "torow",
+    "출력",
+    "문자열",
+    "표시",
+    "포맷",
+    "print",
+    "format",
+    // 단순 위임/조회
+    "크기",
+    "개수",
+    "size",
+    "count",
+    "get",
+    "list",
+    "조회",
+    "반환",
+    "노출",
+];
+function isPassThrough(doing) {
+    const lower = doing.toLowerCase();
+    return PASS_THROUGH_VERBS.some((v) => lower.includes(v));
+}
+function looksLikeCollectionToken(knowing) {
+    const lower = knowing.toLowerCase();
+    if (/(list|collection|set|map|array|리스트|컬렉션|집합|배열|들)/i.test(lower))
+        return true;
+    // 영어 복수형 단순 휴리스틱
+    if (/[a-z]s\b/.test(lower))
+        return true;
+    return false;
+}
+export function checkCollectionWrapperWithoutBehavior(design) {
+    const out = [];
+    for (const card of design.classes) {
+        if (card.stereotype !== "Structurer")
+            continue;
+        const knowing = card.responsibilities.knowing;
+        if (knowing.length > 1)
+            continue; // 다중 knowing은 다른 안티패턴
+        // knowing이 0개거나, 1개가 컬렉션 토큰일 때만 본다.
+        if (knowing.length === 1 && !looksLikeCollectionToken(knowing[0]))
+            continue;
+        const doing = card.responsibilities.doing;
+        // doing이 모두 pass-through(표현/조회)거나 비어 있어야 안티패턴.
+        if (doing.length > 0) {
+            const allPassThrough = doing.every((d) => isPassThrough(d));
+            if (!allPassThrough)
+                continue;
+        }
+        out.push(assertHasMultipleRemedies({
+            rule_id: "collection-wrapper-without-behavior",
+            severity: "info",
+            target: { kind: "class", id: card.id },
+            message: `${card.name}은(는) Structurer로 분류되어 있지만, 컬렉션을 감싸는 것 외에 도메인 행위가 없습니다. ` +
+                `일급 컬렉션은 *역할*이 있을 때만 가치가 있습니다. *역할 없는 wrapper*는 호출자에게 한 겹의 ` +
+                `간접 비용만 더하고 도메인 어휘를 흐립니다.`,
+            evidence: {
+                stereotype: card.stereotype,
+                knowing_count: knowing.length,
+                doing_count: doing.length,
+                example_knowing: knowing[0] ?? null,
+                example_doing: doing[0] ?? null,
+                guideline: "@krrong (lotto PR #144): \"역할과 책임이 없기에 만들지 않는 것도 좋은 근거와 방법이라고 생각해요. " +
+                    "단 *도메인 의미 전달*, *불변성 보장*, *확장성*은 일급 컬렉션의 장점\" — " +
+                    "일급 컬렉션 채택은 *현재 행동* + *예상 확장*의 트레이드오프.",
+            },
+            remedies: [
+                {
+                    label: "도메인 행위를 끌어와 일급 컬렉션의 역할을 부여",
+                    summary: `${card.name}에 *컬렉션 위에서만* 의미 있는 행위(예: 합계, 일치 개수, 우승자 판정, 필터링)를 ` +
+                        `옮긴다. 현재 외부에서 ${card.name}의 데이터를 꺼내 계산하는 호출 지점을 찾아 ` +
+                        `Tell-Don't-Ask로 뒤집는다. 행위가 생기면 wrapper가 *진짜 도메인 객체*가 된다.`,
+                    tradeoffs: {
+                        pros: [
+                            "도메인 어휘가 코드에 드러남 (\"이름들의 합\"이 아니라 \"Names.totalLength()\")",
+                            "컬렉션 불변성을 게이트로 보장 (외부에서 MutableList로 변형 불가)",
+                            "추후 행위가 더 늘어도 한 곳에서 확장 (OCP에 가까워짐)",
+                        ],
+                        cons: [
+                            "현 시점에 행위가 정말 *없다면* 인위적 메서드를 만들 위험",
+                            "행위 이전 작업이 호출자들의 사용 위치 추적을 요구함",
+                        ],
+                    },
+                },
+                {
+                    label: "wrapper 폐기, List<T> 직접 사용 + 행위는 ServiceProvider로",
+                    summary: `${card.name}을 제거하고 호출 지점에서 List<T>를 직접 쓴다. 컬렉션 위에서 도는 도메인 계산은 ` +
+                        `별도 ServiceProvider(또는 확장 함수)로 분리. *역할이 없으면 만들지 않는 것이 정직*하다는 ` +
+                        `@krrong의 균형 답변과 일치.`,
+                    tradeoffs: {
+                        pros: [
+                            "객체 수가 줄어 인지 부담 감소",
+                            "Kotlin 컬렉션 표준 API(map/filter/sumOf)를 자연스럽게 활용",
+                            "*역할 없는 추상*이라는 죽은 코드 제거",
+                        ],
+                        cons: [
+                            "List<Lotto>가 코드 전체에 노출 — 불변성/타입 의미 약화",
+                            "이후 도메인 행위가 생기면 다시 모으는 비용",
+                            "공동 작업자가 List<T>의 도메인적 의미를 코드에서 읽어내야 함",
+                        ],
+                    },
+                },
+                {
+                    label: "유지 + notes에 *명시적 미사용 사유* 기록",
+                    summary: `${card.name}을 그대로 두되, notes에 \"현 시점 행위 없음. *불변성 게이트* 목적으로 유지\" 같은 ` +
+                        `의도를 적어 *방치된 추상*이 아님을 코드 외부에서 기록한다.`,
+                    tradeoffs: {
+                        pros: [
+                            "타입으로 도메인 의미를 *최소한* 유지 (Lottos vs List<Lotto>)",
+                            "행위가 생겼을 때 추가 위치가 이미 준비됨",
+                        ],
+                        cons: [
+                            "*추측 기반* 설계 — 정말 행위가 안 생기면 영구적 잉여물",
+                            "리뷰에서 \"왜 wrapper가 있죠?\"가 반복 질문으로 남음",
+                        ],
+                    },
+                },
+            ],
+        }));
+    }
+    return out;
+}
+//# sourceMappingURL=collectionWrapper.js.map

package/dist/validate/collectionWrapper.js.map

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

package/dist/validate/coupling.d.ts

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

package/dist/validate/coupling.js

@@ -0,0 +1,47 @@
+import { assertHasMultipleRemedies } from "./findings.js";
+export function checkCoupling(design, threshold) {
+    const out = [];
+    for (const card of design.classes) {
+        if (card.collaborators.length <= threshold)
+            continue;
+        out.push(assertHasMultipleRemedies({
+            rule_id: "too-many-collaborators",
+            severity: "warn",
+            target: { kind: "class", id: card.id },
+            message: `${card.name}이(가) ${card.collaborators.length}명의 협력자에 의존합니다. ` +
+                `결합도가 높아 변경 시 영향 범위가 큽니다.`,
+            evidence: {
+                collaborators: card.collaborators.map((c) => c.name),
+                threshold,
+            },
+            remedies: [
+                {
+                    label: "Facade/Mediator로 협력자 묶기",
+                    summary: "관련된 협력자 일부를 하나의 인터페이스 뒤로 숨겨 외부에서 보이는 협력자 수를 줄인다.",
+                    tradeoffs: {
+                        pros: ["호출자 입장의 인터페이스가 단순해진다", "결합 표면이 줄어든다"],
+                        cons: ["간접 계층이 늘어 추적이 어려워질 수 있음"],
+                    },
+                },
+                {
+                    label: "Tell-Don't-Ask: 협력자에게 책임 이전",
+                    summary: "현재 클래스가 협력자들의 상태를 끌어와 처리하고 있다면, 작업을 가지고 있는 협력자에게 옮긴다.",
+                    tradeoffs: {
+                        pros: ["조회 메시지가 줄어든다", "데이터 소유자에게 행위가 모인다"],
+                        cons: ["협력자의 책임이 커질 수 있어 god-object 위험"],
+                    },
+                },
+                {
+                    label: "응집된 협력자 병합",
+                    summary: "사실상 같은 개념을 두 클래스가 나눠 표현 중이라면 합쳐서 협력자 수를 줄인다.",
+                    tradeoffs: {
+                        pros: ["인위적인 경계가 사라짐"],
+                        cons: ["분리가 의도된 경우 응집도가 훼손될 수 있음"],
+                    },
+                },
+            ],
+        }));
+    }
+    return out;
+}
+//# sourceMappingURL=coupling.js.map

package/dist/validate/coupling.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coupling.js","sourceRoot":"","sources":["../../src/validate/coupling.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAE1D,MAAM,UAAU,aAAa,CAC3B,MAAc,EACd,SAAiB;IAEjB,MAAM,GAAG,GAAc,EAAE,CAAC;IAC1B,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;QAClC,IAAI,IAAI,CAAC,aAAa,CAAC,MAAM,IAAI,SAAS;YAAE,SAAS;QACrD,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,QAAQ,IAAI,CAAC,aAAa,CAAC,MAAM,iBAAiB;gBAC9D,0BAA0B;YAC5B,QAAQ,EAAE;gBACR,aAAa,EAAE,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;gBACpD,SAAS;aACV;YACD,QAAQ,EAAE;gBACR;oBACE,KAAK,EAAE,yBAAyB;oBAChC,OAAO,EACL,kDAAkD;oBACpD,SAAS,EAAE;wBACT,IAAI,EAAE,CAAC,sBAAsB,EAAE,aAAa,CAAC;wBAC7C,IAAI,EAAE,CAAC,yBAAyB,CAAC;qBAClC;iBACF;gBACD;oBACE,KAAK,EAAE,6BAA6B;oBACpC,OAAO,EACL,uDAAuD;oBACzD,SAAS,EAAE;wBACT,IAAI,EAAE,CAAC,cAAc,EAAE,mBAAmB,CAAC;wBAC3C,IAAI,EAAE,CAAC,gCAAgC,CAAC;qBACzC;iBACF;gBACD;oBACE,KAAK,EAAE,YAAY;oBACnB,OAAO,EACL,8CAA8C;oBAChD,SAAS,EAAE;wBACT,IAAI,EAAE,CAAC,cAAc,CAAC;wBACtB,IAAI,EAAE,CAAC,0BAA0B,CAAC;qBACnC;iBACF;aACF;SACF,CAAC,CACH,CAAC;IACJ,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/validate/cycle.d.ts

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