oh-my-oop 0.2.0

package/dist/tradeoff/heuristics/collectionShape.js

@@ -0,0 +1,113 @@
+// "*List<T>를 그대로 쓸까, 일급 컬렉션으로 감쌀까*" — Kotlin 도메인에서 자주 보이는 결정.
+// 근거: lotto PR #80, #119, #144 — 특히 #144 @krrong 균형 답변
+// ("역할 없으면 안 만드는 것도 합리. 단 의미/불변성/확장성은 일급 컬렉션 장점").
+export function collectionShapeSeeds(targetName) {
+    const T = targetName || "Items";
+    const single = T.replace(/s$/i, "") || "Item";
+    return [
+        {
+            id: "cs-first-class",
+            label: "일급 컬렉션 (행위 보유)",
+            summary: `${T}을 일급 컬렉션으로 도입하고, *그 위에서만 의미 있는 행위*(합계/일치/우승자 판정/필터)를 ` +
+                `${T} 안으로 끌어온다. 외부에서 List<${single}>를 풀어 다루는 코드는 사라진다.`,
+            design_delta: {
+                added_classes: [{ name: T, stereotype: "Structurer" }],
+            },
+            tradeoffs: {
+                pros: [
+                    "도메인 어휘가 코드에 드러남 (\"List<Lotto>\" 대신 \"Lottos.match(winning)\")",
+                    "*컬렉션 불변성*을 게이트로 보장 (MutableList 변형 방지)",
+                    "도메인 행위가 더 늘어도 한 곳에 모임 (확장성)",
+                    "*Feature Envy*를 자연스럽게 제거",
+                ],
+                cons: [
+                    "*역할 없는 wrapper*가 되면 한 겹 간접 비용만 더함",
+                    "Kotlin 표준 컬렉션 API(map/filter/sumOf)를 *그대로 노출하려면* 위임 코드 작성",
+                    "*초기에 행위가 없으면* 인위적 메서드를 만들 위험",
+                ],
+            },
+            cho_younghos_lens: {
+                cohesion: "improves",
+                coupling: "improves",
+                testability: "improves",
+                notes: "@krrong: \"로또 묶음이 하는 일이 생겼을 때 일급 컬렉션에 로직만 추가하면 되니 변경이 좀 더 자유로움\".",
+            },
+        },
+        {
+            id: "cs-raw-list",
+            label: "List<T> 직접 사용",
+            summary: `${T} wrapper 없이 \`List<${single}>\`를 그대로 사용. 컬렉션 위에서 도는 도메인 계산은 ` +
+                `별도 ServiceProvider(또는 확장 함수)로 분리.`,
+            design_delta: {},
+            tradeoffs: {
+                pros: [
+                    "객체 수 최소 — Kotlin 컬렉션 표준 API를 자연스럽게 활용",
+                    "*행위가 정말 없다면* 정직한 선택 (@krrong: \"만들지 않는 것도 좋은 근거\")",
+                    "*죽은 추상* 회피",
+                ],
+                cons: [
+                    "도메인 의미 상실 (\"List<Lotto>\"가 *어떤 컬렉션인지* 타입에 안 보임)",
+                    "*불변성 보장*이 약함 — MutableList가 우연히 넘어가도 컴파일러가 막지 못함",
+                    "이후 행위가 생기면 *흩어진 호출 지점을 모으는* 비용 발생",
+                ],
+            },
+            cho_younghos_lens: {
+                cohesion: "neutral",
+                coupling: "hurts",
+                testability: "neutral",
+                notes: "도메인 행위가 *진짜로 없는* 단계에서는 정직한 선택이지만 행위가 생기면 회수 신호.",
+            },
+        },
+        {
+            id: "cs-typealias",
+            label: "typealias로 *이름만* 부여",
+            summary: `\`typealias ${T} = List<${single}>\`로 이름만 부여한다. 런타임 구조는 같지만 *읽는 사람*에게 ` +
+                `의도를 전달.`,
+            design_delta: {},
+            tradeoffs: {
+                pros: [
+                    "객체 추가 없이 *도메인 어휘*만 회복",
+                    "Kotlin 표준 API 그대로 사용 가능 (위임 코드 0)",
+                    "*리팩토링 마중물*로 좋음 — 추후 진짜 일급 컬렉션으로 승격하기 쉬움",
+                ],
+                cons: [
+                    "typealias는 *컴파일러 단계에서 동일 타입* — 인자 순서 실수 차단 안 됨",
+                    "*불변성/도메인 행위*는 여전히 부재",
+                    "리뷰어가 \"왜 typealias죠?\"를 물을 수 있음 — 의도 명시 필요",
+                ],
+            },
+            cho_younghos_lens: {
+                cohesion: "neutral",
+                coupling: "neutral",
+                testability: "neutral",
+                notes: "*이름만 회복*하는 카드. 행위가 자라면 일급 컬렉션으로, 안 자라면 typealias도 정직.",
+            },
+        },
+        {
+            id: "cs-inline-class-wrapper",
+            label: "value class wrapper + 위임",
+            summary: `\`@JvmInline value class ${T}(val items: List<${single}>)\`로 감싸 *0 비용*으로 타입 안전성을 얻고, ` +
+                `필요한 행위만 메서드로 노출한다.`,
+            design_delta: {},
+            tradeoffs: {
+                pros: [
+                    "*원시값 수준* 비용 + 도메인 어휘 회복",
+                    "Int/Long 위치와 마찬가지로 컴파일러가 *List<T>와 ${T}를 구분*",
+                    "행위 추가가 점진적으로 가능",
+                ],
+                cons: [
+                    "value class 제약: nullable/제네릭 위치에서 박싱",
+                    "Kotlin 표준 컬렉션 API를 *위임 메서드로 다시 노출*해야 함 (Iterable 위임 패턴)",
+                    "직렬화/리플렉션 호환성 검증 필요",
+                ],
+            },
+            cho_younghos_lens: {
+                cohesion: "improves",
+                coupling: "improves",
+                testability: "improves",
+                notes: "*비용 부담 없이* 이름과 안전성을 회복하는 카드. 행위 자라기 전 단계에 적합.",
+            },
+        },
+    ];
+}
+//# sourceMappingURL=collectionShape.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collectionShape.js","sourceRoot":"","sources":["../../../src/tradeoff/heuristics/collectionShape.ts"],"names":[],"mappings":"AAEA,8DAA8D;AAC9D,uDAAuD;AACvD,mDAAmD;AAEnD,MAAM,UAAU,oBAAoB,CAAC,UAAkB;IACrD,MAAM,CAAC,GAAG,UAAU,IAAI,OAAO,CAAC;IAChC,MAAM,MAAM,GAAG,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,MAAM,CAAC;IAC9C,OAAO;QACL;YACE,EAAE,EAAE,gBAAgB;YACpB,KAAK,EAAE,gBAAgB;YACvB,OAAO,EACL,GAAG,CAAC,uDAAuD;gBAC3D,GAAG,CAAC,wBAAwB,MAAM,qBAAqB;YACzD,YAAY,EAAE;gBACZ,aAAa,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC;aACvD;YACD,SAAS,EAAE;gBACT,IAAI,EAAE;oBACJ,gEAAgE;oBAChE,wCAAwC;oBACxC,6BAA6B;oBAC7B,0BAA0B;iBAC3B;gBACD,IAAI,EAAE;oBACJ,mCAAmC;oBACnC,2DAA2D;oBAC3D,8BAA8B;iBAC/B;aACF;YACD,iBAAiB,EAAE;gBACjB,QAAQ,EAAE,UAAU;gBACpB,QAAQ,EAAE,UAAU;gBACpB,WAAW,EAAE,UAAU;gBACvB,KAAK,EAAE,mEAAmE;aAC3E;SACF;QACD;YACE,EAAE,EAAE,aAAa;YACjB,KAAK,EAAE,eAAe;YACtB,OAAO,EACL,GAAG,CAAC,sBAAsB,MAAM,kCAAkC;gBAClE,mCAAmC;YACrC,YAAY,EAAE,EAAE;YAChB,SAAS,EAAE;gBACT,IAAI,EAAE;oBACJ,uCAAuC;oBACvC,oDAAoD;oBACpD,YAAY;iBACb;gBACD,IAAI,EAAE;oBACJ,kDAAkD;oBAClD,kDAAkD;oBAClD,mCAAmC;iBACpC;aACF;YACD,iBAAiB,EAAE;gBACjB,QAAQ,EAAE,SAAS;gBACnB,QAAQ,EAAE,OAAO;gBACjB,WAAW,EAAE,SAAS;gBACtB,KAAK,EAAE,iDAAiD;aACzD;SACF;QACD;YACE,EAAE,EAAE,cAAc;YAClB,KAAK,EAAE,qBAAqB;YAC5B,OAAO,EACL,eAAe,CAAC,WAAW,MAAM,uCAAuC;gBACxE,SAAS;YACX,YAAY,EAAE,EAAE;YAChB,SAAS,EAAE;gBACT,IAAI,EAAE;oBACJ,uBAAuB;oBACvB,mCAAmC;oBACnC,yCAAyC;iBAC1C;gBACD,IAAI,EAAE;oBACJ,gDAAgD;oBAChD,sBAAsB;oBACtB,4CAA4C;iBAC7C;aACF;YACD,iBAAiB,EAAE;gBACjB,QAAQ,EAAE,SAAS;gBACnB,QAAQ,EAAE,SAAS;gBACnB,WAAW,EAAE,SAAS;gBACtB,KAAK,EAAE,uDAAuD;aAC/D;SACF;QACD;YACE,EAAE,EAAE,yBAAyB;YAC7B,KAAK,EAAE,0BAA0B;YACjC,OAAO,EACL,4BAA4B,CAAC,oBAAoB,MAAM,gCAAgC;gBACvF,oBAAoB;YACtB,YAAY,EAAE,EAAE;YAChB,SAAS,EAAE;gBACT,IAAI,EAAE;oBACJ,yBAAyB;oBACzB,8CAA8C;oBAC9C,iBAAiB;iBAClB;gBACD,IAAI,EAAE;oBACJ,sCAAsC;oBACtC,yDAAyD;oBACzD,oBAAoB;iBACrB;aACF;YACD,iBAAiB,EAAE;gBACjB,QAAQ,EAAE,UAAU;gBACpB,QAAQ,EAAE,UAAU;gBACpB,WAAW,EAAE,UAAU;gBACvB,KAAK,EAAE,+CAA+C;aACvD;SACF;KACF,CAAC;AACJ,CAAC"}

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

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

package/dist/tradeoff/heuristics/dualSubjectComparison.js

@@ -0,0 +1,114 @@
+// "양측이 동등한 두 주체가 어떤 결과(승부·우위·비교)를 결정"하는 협력 패턴.
+// MCP `oh-my-oop` 핵심 가치: *외부 비교자*는 거의 항상 잘못된 첫 답.
+// 근거: lessons/woowacourse-kotlin-blackjack 다수 PR — 외부 정적 Judge.judge / Outcome.of 패턴.
+// @laco-dev (krrong/19): "몇 개 일치하는지 요청해서 결과를 받아오도록 해보세요.
+//                        객체지향 프로그래밍에서는 이 개념을 메시지를 보낸다 라고 표현합니다."
+// @BeokBeok (EmilyCh0/38): "내 카드들의 정보를 넘겨줄테니 블랙잭인지 알려줘."
+export function dualSubjectComparisonSeeds(involved) {
+    const A = involved[0] ?? "Participant";
+    const B = involved[1] ?? "Other";
+    const aMsg = A.charAt(0).toLowerCase() + A.slice(1);
+    const bMsg = B.charAt(0).toLowerCase() + B.slice(1);
+    return [
+        {
+            id: "dsc-external-comparator",
+            label: "외부 비교자 (Judge.judge)",
+            summary: `별도 ServiceProvider 클래스(예: Judge / Outcome.of)가 ${A}와 ${B}의 *데이터를 모두 꺼내* ` +
+                `비교한 후 결과를 반환한다. 양측은 *데이터를 노출*하기만 한다.`,
+            design_delta: {
+                added_classes: [{ name: "Judge", stereotype: "ServiceProvider" }],
+            },
+            tradeoffs: {
+                pros: [
+                    "비교 로직이 *한 자리*에 모임 — \"심판이 룰을 안다\" 메타포와 부합",
+                    "양측 주체에 비교 책임이 없어 *각 주체 클래스는 단순*하게 유지",
+                ],
+                cons: [
+                    "Tell-Don't-Ask 위반 — 양측의 knowing 을 *외부가 꺼내 처리*",
+                    "양측에 *getter 누수* 강제 (캡슐화 약화)",
+                    "*외부 객체 추가*가 가상 객체로 성장할 위험 — @laco-dev: \"객체는 모두 스스로 일을 합니다\"",
+                ],
+            },
+            cho_younghos_lens: {
+                cohesion: "hurts",
+                coupling: "hurts",
+                testability: "neutral",
+                notes: "거의 항상 *잘못된 첫 답*. 비교가 *대칭*이라는 이유로 정당화되지만, 메시지로 풀 수 있다면 그 쪽이 우선.",
+            },
+        },
+        {
+            id: "dsc-one-way-message",
+            label: `일방향 메시지 (${aMsg}.match(${bMsg}))`,
+            summary: `한쪽 주체(${A})가 다른 주체(${B})에게 *결과를 묻는다* — \`${aMsg}.match(${bMsg})\`. ` +
+                `호출 측이 *누가 누구에게 묻는지* 결정한다.`,
+            design_delta: {},
+            tradeoffs: {
+                pros: [
+                    "Tell-Don't-Ask 충실 — 외부에 데이터 노출 X",
+                    `*비교 로직이 ${A}에 응집* (능동적인 측이 책임을 보유)`,
+                    "메시지 방향이 *코드에 명시*되어 협력 그래프가 읽기 쉬움",
+                ],
+                cons: [
+                    `*비대칭* — \`${aMsg}.match(${bMsg})\` 와 \`${bMsg}.match(${aMsg})\` 결과가 같아야 한다면 *수동 일관성* 비용`,
+                    "*어느 쪽이 묻는가*가 호출 지점에 분산 → 호출처가 결정을 떠안음",
+                ],
+            },
+            cho_younghos_lens: {
+                cohesion: "improves",
+                coupling: "improves",
+                testability: "improves",
+                notes: "*객체에게 메시지를 보낸다* 의 가장 직접적 형태. 첫 답으로 가장 자연스러운 카드.",
+            },
+        },
+        {
+            id: "dsc-symmetric-bidirectional",
+            label: "대칭 양방향 메시지",
+            summary: `${A}와 ${B} *양측 모두*에게 비교 메시지를 둔다. 결과의 일관성은 ` +
+                `*공통 invariant*(예: 한쪽 WIN ↔ 다른 쪽 LOSE)로 테스트 또는 코드로 강제.`,
+            design_delta: {},
+            tradeoffs: {
+                pros: [
+                    "*어느 쪽에서나 물을 수 있어* 호출처 자유도 증가",
+                    "비교 책임이 *양측에 대칭*하게 응집 — 한쪽이 비대해질 위험 ↓",
+                ],
+                cons: [
+                    "*결과 일관성 강제* 비용 — 한쪽 룰 변경 시 양측 모두 갱신 필요",
+                    "*중복 로직* 위험 — 결국 한쪽이 다른 쪽을 호출하는 구조로 수렴 가능",
+                    "*테스트 매트릭스 N²* — 양방향 케이스를 모두 검증",
+                ],
+            },
+            cho_younghos_lens: {
+                cohesion: "neutral",
+                coupling: "neutral",
+                testability: "neutral",
+                notes: "*동등성이 본질*인 도메인(양측이 동시에 결정을 행사)에 적합. 비대칭이라면 일방향 메시지가 더 자연.",
+            },
+        },
+        {
+            id: "dsc-state-self-judging",
+            label: "State 자가 판정 (state.compareTo(other))",
+            summary: `${A}와 ${B}가 *각자 State 객체*를 가지며, 비교는 \`State.compareTo(otherState)\` 다형성으로 풀린다. ` +
+                `상태별 *고유 비교 룰*을 sealed 다형성이 표현 (예: Bust 는 항상 패배).`,
+            design_delta: {},
+            tradeoffs: {
+                pros: [
+                    "상태별 *고유 비교 룰*을 다형성으로 자연 표현",
+                    "비교 책임이 *주체에서 상태로 이동* — 주체 클래스 단순화",
+                    "*분기 N×M 폭증* 회피 (state-machine 학습 장치)",
+                ],
+                cons: [
+                    "*State 패턴 도입 비용* — sealed/abstract 계층 + 전이 룰 추가 학습",
+                    "*외부 mutation 위험* (state private 강제 필요)",
+                    "비교가 *단순한 산술*이라면 과설계",
+                ],
+            },
+            cho_younghos_lens: {
+                cohesion: "improves",
+                coupling: "improves",
+                testability: "improves",
+                notes: "분기 폭증을 *경험한 후* 도달할 카드. 처음부터 도입하면 *그저 좋다*의 함정 (@ghojeong State 패턴 2 기준: 다형성 활용 + Context 책임).",
+            },
+        },
+    ];
+}
+//# sourceMappingURL=dualSubjectComparison.js.map

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

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

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

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

package/dist/tradeoff/heuristics/errorHandling.js

@@ -0,0 +1,110 @@
+// "*외부에서 들어온 잘못된 입력*을 어떻게 다룰까" — 재입력/예외/Result/null+while 선택.
+// 근거: lotto PR #5, #36, #50, #90 (입력 검증 + 재입력 흐름).
+export function errorHandlingSeeds(targetName) {
+    const T = targetName || "Input";
+    return [
+        {
+            id: "eh-runcatching-loop",
+            label: "runCatching + 외부 루프",
+            summary: `${T} 처리 메서드는 require로 *unhappy path를 예외로* 끝낸다. ` +
+                `재시도 흐름은 호출 지점에서 \`runCatching { ... }.onFailure { ... }\` 루프로 표현.`,
+            design_delta: {},
+            tradeoffs: {
+                pros: [
+                    "*도메인 객체는 unhappy path를 모름* — 단일 책임 유지",
+                    "재시도 정책이 *Coordinator/Controller에 한 곳에서* 표현",
+                    "*invariant가 깨지면 예외*라는 Kotlin 관용을 따름",
+                ],
+                cons: [
+                    "예외가 *제어 흐름*으로 쓰이면 비용/혼란 증가",
+                    "runCatching이 catch-all로 동작 — *예상치 못한 예외*도 같이 삼킬 위험",
+                    "Result 체이닝 깊이가 깊어지면 코드 가독성 저하",
+                ],
+            },
+            cho_younghos_lens: {
+                cohesion: "improves",
+                coupling: "improves",
+                testability: "improves",
+                notes: "도메인은 *행복 경로*만 안다는 분리가 가장 객체지향적.",
+            },
+        },
+        {
+            id: "eh-null-while",
+            label: "null + while 루프",
+            summary: `재입력이 필요하면 \`tryParse()\`가 null을 반환하고 호출자가 \`while (result == null) { ... }\`로 ` +
+                `반복한다. 예외를 *흐름 제어로 쓰지 않는* 보수적 선택.`,
+            design_delta: {},
+            tradeoffs: {
+                pros: [
+                    "예외를 흐름으로 쓰지 않음 — 성능/관용 모두 안전",
+                    "null이 *복구 가능한 실패*임을 타입이 알려줌",
+                    "단순한 입력 재시도에 가장 가벼움",
+                ],
+                cons: [
+                    "*실패 이유*가 null 한 종류로 뭉개짐 — 사용자에게 *왜* 실패했는지 알려주기 어려움",
+                    "null 처리 + 루프가 호출 지점마다 반복 — *재입력 로직 중복*",
+                    "Kotlin의 *nullable 의미*가 \"실패\" + \"부재\" 두 의미로 오버로드",
+                ],
+            },
+            cho_younghos_lens: {
+                cohesion: "neutral",
+                coupling: "neutral",
+                testability: "neutral",
+                notes: "*도메인 의미가 단순 부재*에 가깝다면 자연. 실패 이유가 풍부하면 부족.",
+            },
+        },
+        {
+            id: "eh-result-type",
+            label: "Result<T> / sealed class 타입화",
+            summary: `\`sealed class ParseResult { data class Ok(val value: T) : ParseResult(); data class Err(val reason: ErrorKind) : ParseResult() }\` ` +
+                `같이 *성공/실패를 타입으로* 표현. 호출자가 when으로 분기.`,
+            design_delta: {},
+            tradeoffs: {
+                pros: [
+                    "*실패 이유*를 타입으로 풍부하게 표현 (사용자에게 정확한 안내 가능)",
+                    "exhaustive when으로 *모든 케이스* 컴파일 검증",
+                    "예외/null 어느 쪽도 흐름 제어로 쓰지 않음 — *함수형* 스타일",
+                ],
+                cons: [
+                    "*결과 타입 보일러플레이트* 증가 (sealed class 정의, when 분기)",
+                    "호출 사이트마다 ParseResult 처리 — 코드 폭이 늘 수 있음",
+                    "*Kotlin 표준 Result*와 혼동될 수 있어 도메인용은 별도 명명 필요",
+                ],
+            },
+            cho_younghos_lens: {
+                cohesion: "improves",
+                coupling: "improves",
+                testability: "improves",
+                notes: "실패에도 *도메인 의미*가 있다면 가장 정직한 표현.",
+            },
+        },
+        {
+            id: "eh-coordinator-policy",
+            label: "Coordinator에 *재입력 정책* 격리",
+            summary: `도메인 객체는 require로 끝나고, 재입력 루프/사용자 안내/포기 조건은 \`InputCoordinator\` 같은 ` +
+                `별도 Coordinator가 책임진다. *입력 정책*과 *도메인 invariant*를 객체로 분리.`,
+            design_delta: {
+                added_classes: [{ name: "InputCoordinator", stereotype: "Coordinator" }],
+            },
+            tradeoffs: {
+                pros: [
+                    "*재입력 횟수 제한*, *기본값 대체* 같은 정책 변경이 한 곳에서",
+                    "도메인 객체는 *행복 경로*만 신경 — 인지 부담 분산",
+                    "테스트가 *입력 정책 vs 도메인 invariant*로 깔끔히 갈림",
+                ],
+                cons: [
+                    "객체 수 증가 — *재입력 1회* 같은 단순 도메인엔 과설계",
+                    "Coordinator가 *상태를 길게 들고 있는* 위험 (lateinit var 등 안티)",
+                    "*UI 흐름*과 *도메인*을 잇는 추가 레이어가 호출 그래프를 깊게 함",
+                ],
+            },
+            cho_younghos_lens: {
+                cohesion: "improves",
+                coupling: "improves",
+                testability: "improves",
+                notes: "*재입력이 정책이 되는 순간* Coordinator로 끌어올리는 것이 정직.",
+            },
+        },
+    ];
+}
+//# sourceMappingURL=errorHandling.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errorHandling.js","sourceRoot":"","sources":["../../../src/tradeoff/heuristics/errorHandling.ts"],"names":[],"mappings":"AAEA,8DAA8D;AAC9D,mDAAmD;AAEnD,MAAM,UAAU,kBAAkB,CAAC,UAAkB;IACnD,MAAM,CAAC,GAAG,UAAU,IAAI,OAAO,CAAC;IAChC,OAAO;QACL;YACE,EAAE,EAAE,qBAAqB;YACzB,KAAK,EAAE,qBAAqB;YAC5B,OAAO,EACL,GAAG,CAAC,6CAA6C;gBACjD,mEAAmE;YACrE,YAAY,EAAE,EAAE;YAChB,SAAS,EAAE;gBACT,IAAI,EAAE;oBACJ,uCAAuC;oBACvC,4CAA4C;oBAC5C,qCAAqC;iBACtC;gBACD,IAAI,EAAE;oBACJ,4BAA4B;oBAC5B,oDAAoD;oBACpD,+BAA+B;iBAChC;aACF;YACD,iBAAiB,EAAE;gBACjB,QAAQ,EAAE,UAAU;gBACpB,QAAQ,EAAE,UAAU;gBACpB,WAAW,EAAE,UAAU;gBACvB,KAAK,EAAE,iCAAiC;aACzC;SACF;QACD;YACE,EAAE,EAAE,eAAe;YACnB,KAAK,EAAE,iBAAiB;YACxB,OAAO,EACL,gFAAgF;gBAChF,kCAAkC;YACpC,YAAY,EAAE,EAAE;YAChB,SAAS,EAAE;gBACT,IAAI,EAAE;oBACJ,8BAA8B;oBAC9B,6BAA6B;oBAC7B,oBAAoB;iBACrB;gBACD,IAAI,EAAE;oBACJ,oDAAoD;oBACpD,wCAAwC;oBACxC,mDAAmD;iBACpD;aACF;YACD,iBAAiB,EAAE;gBACjB,QAAQ,EAAE,SAAS;gBACnB,QAAQ,EAAE,SAAS;gBACnB,WAAW,EAAE,SAAS;gBACtB,KAAK,EAAE,2CAA2C;aACnD;SACF;QACD;YACE,EAAE,EAAE,gBAAgB;YACpB,KAAK,EAAE,8BAA8B;YACrC,OAAO,EACL,sIAAsI;gBACtI,sCAAsC;YACxC,YAAY,EAAE,EAAE;YAChB,SAAS,EAAE;gBACT,IAAI,EAAE;oBACJ,yCAAyC;oBACzC,mCAAmC;oBACnC,wCAAwC;iBACzC;gBACD,IAAI,EAAE;oBACJ,+CAA+C;oBAC/C,wCAAwC;oBACxC,6CAA6C;iBAC9C;aACF;YACD,iBAAiB,EAAE;gBACjB,QAAQ,EAAE,UAAU;gBACpB,QAAQ,EAAE,UAAU;gBACpB,WAAW,EAAE,UAAU;gBACvB,KAAK,EAAE,+BAA+B;aACvC;SACF;QACD;YACE,EAAE,EAAE,uBAAuB;YAC3B,KAAK,EAAE,0BAA0B;YACjC,OAAO,EACL,qEAAqE;gBACrE,yDAAyD;YAC3D,YAAY,EAAE;gBACZ,aAAa,EAAE,CAAC,EAAE,IAAI,EAAE,kBAAkB,EAAE,UAAU,EAAE,aAAa,EAAE,CAAC;aACzE;YACD,SAAS,EAAE;gBACT,IAAI,EAAE;oBACJ,uCAAuC;oBACvC,gCAAgC;oBAChC,uCAAuC;iBACxC;gBACD,IAAI,EAAE;oBACJ,mCAAmC;oBACnC,oDAAoD;oBACpD,yCAAyC;iBAC1C;aACF;YACD,iBAAiB,EAAE;gBACjB,QAAQ,EAAE,UAAU;gBACpB,QAAQ,EAAE,UAAU;gBACpB,WAAW,EAAE,UAAU;gBACvB,KAAK,EAAE,4CAA4C;aACpD;SACF;KACF,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,23 @@
+import type { UseCase } from "../../domain/model.js";
+import type { Stereotype } from "../../domain/stereotypes.js";
+export interface ResponsibilityAssignment {
+    responsibility: string;
+    kind: "knowing" | "doing";
+    candidate_class: string;
+    candidate_stereotype: Stereotype;
+}
+export interface ResponsibilityAlternative {
+    id: string;
+    name: string;
+    rationale: string;
+    tradeoffs: {
+        pros: string[];
+        cons: string[];
+    };
+    assignments: ResponsibilityAssignment[];
+}
+export declare function seedsByNoun(uc: UseCase): ResponsibilityAlternative;
+export declare function seedsByVerb(uc: UseCase): ResponsibilityAlternative;
+export declare function seedsSingleClass(uc: UseCase): ResponsibilityAlternative;
+export declare function seedsByStereotype(uc: UseCase): ResponsibilityAlternative;
+export declare function buildResponsibilitySeeds(uc: UseCase, bias?: "by-noun" | "by-verb" | "balanced"): ResponsibilityAlternative[];

package/dist/tradeoff/heuristics/responsibilitySplit.js

@@ -0,0 +1,183 @@
+const NOUN_HINT = /([가-힣A-Za-z]+(?:들|s)?)/g;
+const VERB_RE = /([가-힣A-Za-z]+(?:다|s|e|기|함|이|하기)?)/g;
+function topNounCandidates(text, limit = 3) {
+    const counts = new Map();
+    const matches = text.match(NOUN_HINT) ?? [];
+    for (const raw of matches) {
+        const t = raw.trim();
+        if (t.length < 2)
+            continue;
+        counts.set(t, (counts.get(t) ?? 0) + 1);
+    }
+    return [...counts.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, limit)
+        .map(([n]) => capitalize(n));
+}
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function actionsFromFlow(uc) {
+    return uc.main_flow.slice();
+}
+export function seedsByNoun(uc) {
+    const nouns = topNounCandidates(`${uc.title} ${uc.main_flow.join(" ")}`);
+    const top = nouns[0] ?? "Subject";
+    const second = nouns[1] ?? "Detail";
+    const assignments = [
+        {
+            responsibility: `${top} 정보를 안다`,
+            kind: "knowing",
+            candidate_class: top,
+            candidate_stereotype: "InformationHolder",
+        },
+        {
+            responsibility: `${second} 정보를 안다`,
+            kind: "knowing",
+            candidate_class: second,
+            candidate_stereotype: "InformationHolder",
+        },
+    ];
+    for (const step of actionsFromFlow(uc)) {
+        assignments.push({
+            responsibility: step,
+            kind: "doing",
+            candidate_class: top,
+            candidate_stereotype: "ServiceProvider",
+        });
+    }
+    return {
+        id: "alt-by-noun",
+        name: "도메인 명사 중심 분해",
+        rationale: `유스케이스에서 가장 자주 등장한 명사(${top}, ${second})를 1급 객체로 보고 그 주변에 책임을 모았습니다.`,
+        tradeoffs: {
+            pros: [
+                "도메인 모델이 코드에 1:1로 드러난다",
+                "값 객체가 자연스럽게 등장한다",
+                "이름이 짧고 도메인 언어를 따른다",
+            ],
+            cons: [
+                "행위(doing) 책임의 자리가 명확하지 않을 수 있다",
+                "협력 흐름을 보려면 추가 사고가 필요하다",
+            ],
+        },
+        assignments,
+    };
+}
+export function seedsByVerb(uc) {
+    const actions = actionsFromFlow(uc);
+    const services = actions.map((a, i) => `${verbToName(a)}Service`).filter((s, i, arr) => arr.indexOf(s) === i);
+    const assignments = [];
+    actions.forEach((step, i) => {
+        const name = services[i] ?? services[0] ?? "ActionService";
+        assignments.push({
+            responsibility: step,
+            kind: "doing",
+            candidate_class: name,
+            candidate_stereotype: "ServiceProvider",
+        });
+    });
+    return {
+        id: "alt-by-verb",
+        name: "행위(유스케이스 단계) 중심 분해",
+        rationale: "유스케이스의 각 단계(동사)를 ServiceProvider 단위로 잘랐습니다. 절차가 명확합니다.",
+        tradeoffs: {
+            pros: [
+                "유스케이스 흐름이 코드 구조로 그대로 드러남",
+                "각 단계가 단위테스트하기 좋음",
+            ],
+            cons: [
+                "도메인 명사가 1급으로 표현되지 않음",
+                "절차적 코드에 가까워질 수 있음 (객체지향의 장점이 약해짐)",
+            ],
+        },
+        assignments,
+    };
+}
+export function seedsSingleClass(uc) {
+    const top = topNounCandidates(uc.title)[0] ?? "Game";
+    const assignments = [];
+    for (const step of uc.main_flow) {
+        assignments.push({
+            responsibility: step,
+            kind: "doing",
+            candidate_class: top,
+            candidate_stereotype: "Coordinator",
+        });
+    }
+    return {
+        id: "alt-single-class",
+        name: "단일 Coordinator로 시작",
+        rationale: "처음엔 한 클래스로 시작하고 통증이 보이는 책임만 추출하는 점진적 접근입니다.",
+        tradeoffs: {
+            pros: [
+                "초기 설계 비용이 가장 낮음",
+                "실제 마찰이 보인 뒤 분리하므로 과설계 위험이 적음",
+            ],
+            cons: [
+                "방치 시 god-object로 자라기 쉬움",
+                "테스트 단위가 커진다",
+            ],
+        },
+        assignments,
+    };
+}
+export function seedsByStereotype(uc) {
+    const top = topNounCandidates(uc.title)[0] ?? "Game";
+    const assignments = [
+        {
+            responsibility: "유스케이스 진입과 호출 순서를 조율한다",
+            kind: "doing",
+            candidate_class: `${top}Coordinator`,
+            candidate_stereotype: "Coordinator",
+        },
+        {
+            responsibility: `${top} 도메인 정보를 안다`,
+            kind: "knowing",
+            candidate_class: top,
+            candidate_stereotype: "InformationHolder",
+        },
+        {
+            responsibility: "도메인 규칙을 계산한다",
+            kind: "doing",
+            candidate_class: `${top}Rule`,
+            candidate_stereotype: "ServiceProvider",
+        },
+    ];
+    for (const step of uc.main_flow) {
+        assignments.push({
+            responsibility: step,
+            kind: "doing",
+            candidate_class: `${top}Coordinator`,
+            candidate_stereotype: "Coordinator",
+        });
+    }
+    return {
+        id: "alt-by-stereotype",
+        name: "Stereotype 5종으로 사전 분류",
+        rationale: "Coordinator / Information Holder / Service Provider / (필요 시 Interfacer)로 책임의 종류부터 분리합니다.",
+        tradeoffs: {
+            pros: [
+                "역할이 명시적이라 god-object 위험이 낮음",
+                "각 클래스가 한 가지 이유로만 변경된다",
+            ],
+            cons: [
+                "초기 객체 수가 많아 학습 곡선 상승",
+                "유스케이스가 단순할 때 과설계 위험",
+            ],
+        },
+        assignments,
+    };
+}
+function verbToName(step) {
+    const cleaned = step.replace(/[^A-Za-z가-힣]+/g, " ").trim().split(/\s+/)[0] ?? "Action";
+    return capitalize(cleaned);
+}
+export function buildResponsibilitySeeds(uc, bias) {
+    if (bias === "by-noun")
+        return [seedsByNoun(uc), seedsByStereotype(uc), seedsSingleClass(uc)];
+    if (bias === "by-verb")
+        return [seedsByVerb(uc), seedsByStereotype(uc), seedsSingleClass(uc)];
+    return [seedsByNoun(uc), seedsByVerb(uc), seedsByStereotype(uc), seedsSingleClass(uc)];
+}
+//# sourceMappingURL=responsibilitySplit.js.map

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

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

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

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

package/dist/tradeoff/heuristics/stereotypeChoice.js

@@ -0,0 +1,23 @@
+import { STEREOTYPES, STEREOTYPE_HINTS } from "../../domain/stereotypes.js";
+export function stereotypeChoiceSeeds(targetName) {
+    return STEREOTYPES.map((s) => {
+        const hints = STEREOTYPE_HINTS[s];
+        return {
+            id: `stereotype-${s.toLowerCase()}`,
+            label: s,
+            summary: `${targetName}을 ${s}로 분류한다.`,
+            design_delta: {},
+            tradeoffs: {
+                pros: hints.fits.map((f) => `적합: ${f}`),
+                cons: hints.misfits.map((m) => `부적합 가능성: ${m}`),
+            },
+            cho_younghos_lens: {
+                cohesion: "neutral",
+                coupling: "neutral",
+                testability: s === "ServiceProvider" || s === "InformationHolder" ? "improves" : "neutral",
+                notes: `${s}는 ${hints.fits[0] ?? "특정 상황"}에 가장 어울린다.`,
+            },
+        };
+    });
+}
+//# sourceMappingURL=stereotypeChoice.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stereotypeChoice.js","sourceRoot":"","sources":["../../../src/tradeoff/heuristics/stereotypeChoice.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAE5E,MAAM,UAAU,qBAAqB,CAAC,UAAkB;IACtD,OAAO,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;QAC3B,MAAM,KAAK,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC;QAClC,OAAO;YACL,EAAE,EAAE,cAAc,CAAC,CAAC,WAAW,EAAE,EAAE;YACnC,KAAK,EAAE,CAAC;YACR,OAAO,EAAE,GAAG,UAAU,KAAK,CAAC,SAAS;YACrC,YAAY,EAAE,EAAE;YAChB,SAAS,EAAE;gBACT,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC;gBACvC,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,YAAY,CAAC,EAAE,CAAC;aAChD;YACD,iBAAiB,EAAE;gBACjB,QAAQ,EAAE,SAAkB;gBAC5B,QAAQ,EAAE,SAAkB;gBAC5B,WAAW,EAAE,CAAC,KAAK,iBAAiB,IAAI,CAAC,KAAK,mBAAmB,CAAC,CAAC,CAAC,UAAmB,CAAC,CAAC,CAAC,SAAkB;gBAC5G,KAAK,EAAE,GAAG,CAAC,KAAK,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,OAAO,YAAY;aACrD;SACF,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC"}

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

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