muno-claude-plugin 1.2.0 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "muno-claude-plugin",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Unleash Claude Code's full power - Complete development workflow with expert personas, TDD-based agents, and automated documentation",
   "main": "bin/cli.js",
   "bin": {

package/templates/agents/acceptance-test-generator.md

@@ -169,37 +169,33 @@ status: ready
 
 ## 출력: 인수 테스트 코드
 
-### Integration Test 패턴
+### 프로젝트 언어 감지
+
+**테스트 코드 생성 전 반드시 프로젝트의 기술 스택을 파악합니다:**
+
+```
+1. build.gradle.kts / build.gradle → Kotlin/Java + Spring
+2. pom.xml → Java + Spring
+3. package.json → TypeScript/JavaScript + Node.js
+4. requirements.txt / pyproject.toml → Python
+5. go.mod → Go
+6. 기존 테스트 코드 패턴 확인 → 프로젝트 컨벤션 따르기
+```
+
+---
+
+## 언어별 Integration Test 패턴
+
+### Kotlin + Spring Boot
 
 ```kotlin
-package com.example.integration.chat
-
-import org.junit.jupiter.api.*
-import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc
-import org.springframework.boot.test.context.SpringBootTest
-import org.springframework.http.MediaType
-import org.springframework.test.web.servlet.MockMvc
-import org.springframework.test.web.servlet.post
-import org.springframework.transaction.annotation.Transactional
-
-/**
- * STORY-001: 채팅방 관리
- *
- * TC 기반 인수 테스트 - Story 완료 검증
- * TC 생성 직후 작성 (Test First)
- */
 @SpringBootTest
 @AutoConfigureMockMvc
 @Transactional
 @DisplayName("STORY-001: 채팅방 관리 인수 테스트")
 class ChatRoomAcceptanceTest {
 
-    @Autowired
-    lateinit var mockMvc: MockMvc
-
-    @Autowired
-    lateinit var chatRoomRepository: ChatRoomRepository
+    @Autowired lateinit var mockMvc: MockMvc
 
     @Nested
     @DisplayName("TC-001-01: 채팅방 생성 - Happy Path")
@@ -207,50 +203,10 @@ class ChatRoomAcceptanceTest {
 
         @Test
         @DisplayName("인증된 사용자가 유효한 제목으로 채팅방 생성 시 성공")
-        fun `POST api_chat-rooms - 201 Created with chatRoomId`() {
-            // Arrange (사전 조건)
-            val token = createTestUserToken(userId = 1L)
-            val requestBody = """
-                {
-                    "title": "새 채팅방"
-                }
-            """.trimIndent()
-
-            // Act (실행 단계)
-            val result = mockMvc.post("/api/chat-rooms") {
-                contentType = MediaType.APPLICATION_JSON
-                content = requestBody
-                header("Authorization", "Bearer $token")
-            }
-
-            // Assert (기대 결과)
-            result.andExpect {
-                status { isCreated() }
-                jsonPath("$.chatRoomId") { exists() }
-                jsonPath("$.title") { value("새 채팅방") }
-            }
-
-            // DB 검증
-            val chatRooms = chatRoomRepository.findAll()
-            assertThat(chatRooms).hasSize(1)
-            assertThat(chatRooms[0].title).isEqualTo("새 채팅방")
-        }
-    }
-
-    @Nested
-    @DisplayName("TC-001-02: 채팅방 생성 - 빈 제목 오류")
-    inner class TC_001_02_EmptyTitle {
-
-        @Test
-        @DisplayName("빈 제목으로 채팅방 생성 시 400 Bad Request")
-        fun `POST api_chat-rooms with empty title - 400 Bad Request`() {
+        fun `POST api_chat-rooms - 201 Created`() {
             // Arrange
             val token = createTestUserToken(userId = 1L)
-            val requestBody = """
-                {
-                    "title": ""
-                }
-            """.trimIndent()
+            val requestBody = """{"title": "새 채팅방"}"""
 
             // Act & Assert
             mockMvc.post("/api/chat-rooms") {
@@ -258,86 +214,135 @@ class ChatRoomAcceptanceTest {
                 content = requestBody
                 header("Authorization", "Bearer $token")
             }.andExpect {
-                status { isBadRequest() }
-                jsonPath("$.error") { exists() }
+                status { isCreated() }
+                jsonPath("$.chatRoomId") { exists() }
             }
         }
     }
+}
+```
+
+### Java + Spring Boot
+
+```java
+@SpringBootTest
+@AutoConfigureMockMvc
+@Transactional
+@DisplayName("STORY-001: 채팅방 관리 인수 테스트")
+class ChatRoomAcceptanceTest {
+
+    @Autowired
+    private MockMvc mockMvc;
 
     @Nested
-    @DisplayName("TC-001-03: 인증 없이 채팅방 생성 시도")
-    inner class TC_001_03_Unauthorized {
+    @DisplayName("TC-001-01: 채팅방 생성 - Happy Path")
+    class TC_001_01_CreateChatRoom {
 
         @Test
-        @DisplayName("인증 토큰 없이 채팅방 생성 시 401 Unauthorized")
-        fun `POST api_chat-rooms without token - 401 Unauthorized`() {
+        @DisplayName("인증된 사용자가 유효한 제목으로 채팅방 생성 시 성공")
+        void createChatRoom_withValidTitle_returns201() throws Exception {
             // Arrange
-            val requestBody = """
-                {
-                    "title": "새 채팅방"
-                }
-            """.trimIndent()
+            String requestBody = """{"title": "새 채팅방"}""";
 
             // Act & Assert
-            mockMvc.post("/api/chat-rooms") {
-                contentType = MediaType.APPLICATION_JSON
-                content = requestBody
-            }.andExpect {
-                status { isUnauthorized() }
-            }
+            mockMvc.perform(post("/api/chat-rooms")
+                    .contentType(MediaType.APPLICATION_JSON)
+                    .content(requestBody)
+                    .header("Authorization", "Bearer " + testToken))
+                .andExpect(status().isCreated())
+                .andExpect(jsonPath("$.chatRoomId").exists());
         }
     }
-
-    private fun createTestUserToken(userId: Long): String {
-        // 테스트용 JWT 토큰 생성
-        return "test-token-for-user-$userId"
-    }
 }
 ```
 
----
+### TypeScript + Jest + Supertest
+
+```typescript
+describe('STORY-001: 채팅방 관리 인수 테스트', () => {
+  describe('TC-001-01: 채팅방 생성 - Happy Path', () => {
+    it('인증된 사용자가 유효한 제목으로 채팅방 생성 시 성공', async () => {
+      // Arrange
+      const token = await createTestUserToken(1);
+      const requestBody = { title: '새 채팅방' };
+
+      // Act
+      const response = await request(app)
+        .post('/api/chat-rooms')
+        .set('Authorization', `Bearer ${token}`)
+        .send(requestBody);
+
+      // Assert
+      expect(response.status).toBe(201);
+      expect(response.body.chatRoomId).toBeDefined();
+    });
+  });
+});
+```
 
-## 테스트 유형별 패턴
+### Python + pytest + FastAPI/Django
+
+```python
+import pytest
+from httpx import AsyncClient
+
+class TestChatRoomAcceptance:
+    """STORY-001: 채팅방 관리 인수 테스트"""
+
+    class TestTC_001_01_CreateChatRoom:
+        """TC-001-01: 채팅방 생성 - Happy Path"""
+
+        @pytest.mark.asyncio
+        async def test_create_chatroom_with_valid_title_returns_201(
+            self, client: AsyncClient, auth_token: str
+        ):
+            response = await client.post(
+                "/api/chat-rooms",
+                json={"title": "새 채팅방"},
+                headers={"Authorization": f"Bearer {auth_token}"}
+            )
+            assert response.status_code == 201
+            assert "chatRoomId" in response.json()
+```
 
-### Integration Test (API 레벨)
+### Go + testing + httptest
 
-```kotlin
-@SpringBootTest
-@AutoConfigureMockMvc
-@Transactional
-class XxxAcceptanceTest {
-    @Autowired lateinit var mockMvc: MockMvc
+```go
+func TestChatRoomAcceptance(t *testing.T) {
+    t.Run("TC-001-01: 채팅방 생성 - Happy Path", func(t *testing.T) {
+        // Arrange
+        token := createTestUserToken(1)
+        body := `{"title": "새 채팅방"}`
 
-    @Nested
-    @DisplayName("TC-XXX-XX: 시나리오명")
-    inner class TC_XXX_XX { ... }
-}
-```
+        req := httptest.NewRequest("POST", "/api/chat-rooms", strings.NewReader(body))
+        req.Header.Set("Authorization", "Bearer "+token)
 
-### E2E Test (전체 흐름)
+        // Act
+        rec := httptest.NewRecorder()
+        router.ServeHTTP(rec, req)
 
-```kotlin
-@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
-@TestMethodOrder(MethodOrderer.OrderAnnotation::class)
-class XxxE2ETest {
-    @Autowired lateinit var restTemplate: TestRestTemplate
-
-    @Test
-    @Order(1)
-    fun `Step 1: 사용자 생성`() { ... }
-
-    @Test
-    @Order(2)
-    fun `Step 2: 로그인`() { ... }
-
-    @Test
-    @Order(3)
-    fun `Step 3: 채팅방 생성`() { ... }
+        // Assert
+        assert.Equal(t, http.StatusCreated, rec.Code)
+    })
 }
 ```
 
 ---
 
+## 테스트 유형별 패턴 (언어 공통)
+
+### Integration Test (API 레벨)
+- HTTP 요청/응답 검증
+- DB 상태 검증
+- 트랜잭션 롤백으로 격리
+
+### E2E Test (전체 흐름)
+- 실제 서버 구동 (랜덤 포트)
+- 순차적 시나리오 실행
+- 외부 의존성 Mock 또는 실제 연동
+
+---
+
 ## 생성 워크플로우
 
 ### Step 1: TC 분석

package/templates/agents/epic-story-reviewer.md

@@ -1,7 +1,7 @@
 ---
 name: epic-story-reviewer
 description: Epic/Story 문서를 체크리스트 기반으로 검토합니다. 통과하면 OK, 문제 있을 때만 피드백합니다.
-model: opus
+model: sonnet
 color: blue
 ---
 

package/templates/agents/prd-reviewer.md

@@ -1,7 +1,7 @@
 ---
 name: prd-reviewer
 description: PRD 문서를 체크리스트 기반으로 검토합니다. 통과하면 OK, 문제 있을 때만 피드백합니다.
-model: opus
+model: sonnet
 color: red
 ---
 

package/templates/agents/tc-reviewer.md

@@ -1,7 +1,7 @@
 ---
 name: tc-reviewer
 description: TC 문서를 체크리스트 기반으로 검토합니다. 통과하면 OK, 문제 있을 때만 피드백합니다.
-model: opus
+model: sonnet
 color: purple
 ---
 

package/templates/agents/unit-test-generator.md

@@ -153,21 +153,26 @@ status: todo
 
 ## 출력: Unit Test 코드
 
-### 생성 패턴
+### 프로젝트 언어 감지
+
+**테스트 코드 생성 전 반드시 프로젝트의 기술 스택을 파악합니다:**
+
+```
+1. build.gradle.kts / build.gradle → Kotlin/Java + Spring
+2. pom.xml → Java + Spring
+3. package.json → TypeScript/JavaScript + Node.js
+4. requirements.txt / pyproject.toml → Python
+5. go.mod → Go
+6. 기존 테스트 코드 패턴 확인 → 프로젝트 컨벤션 따르기
+```
+
+---
+
+## 언어별 Unit Test 패턴
+
+### Kotlin + JUnit5
 
 ```kotlin
-package com.example.domain.chat.model
-
-import org.junit.jupiter.api.*
-import org.assertj.core.api.Assertions.assertThat
-import org.assertj.core.api.Assertions.assertThatThrownBy
-
-/**
- * TASK-001: ChatRoom Entity 생성
- *
- * TDD 기반 Unit Test - 구현 전 작성
- * Task 완료 조건을 검증하는 테스트
- */
 @DisplayName("ChatRoom Entity 테스트")
 class ChatRoomTest {
 
@@ -176,8 +181,8 @@ class ChatRoomTest {
     inner class Creation {
 
         @Test
-        @DisplayName("유효한 값으로 Entity 생성 시 성공한다")
-        fun `유효한 userId와 title로 ChatRoom 생성 시 externalId가 자동 생성된다`() {
+        @DisplayName("유효한 값으로 Entity 생성 시 성공")
+        fun `유효한 userId와 title로 ChatRoom 생성 시 성공`() {
             // Arrange
             val userId = 1L
             val title = "테스트 채팅방"
@@ -187,80 +192,150 @@ class ChatRoomTest {
 
             // Assert
             assertThat(chatRoom.externalId).isNotNull()
-            assertThat(chatRoom.userId).isEqualTo(userId)
             assertThat(chatRoom.title).isEqualTo(title)
-            assertThat(chatRoom.status).isEqualTo(ChatRoomStatus.ACTIVE)
-        }
-
-        @Test
-        @DisplayName("externalId는 UUIDv7 형식이다")
-        fun `externalId는 UUIDv7 형식으로 생성된다`() {
-            // Arrange & Act
-            val chatRoom = ChatRoom(userId = 1L, title = "테스트")
-
-            // Assert
-            assertThat(chatRoom.externalId).isNotNull()
-            assertThat(chatRoom.externalId.toString()).matches(
-                "^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
-            )
         }
     }
 
     @Nested
-    @DisplayName("Title 유효성 검증")
-    inner class TitleValidation {
+    @DisplayName("유효성 검증")
+    inner class Validation {
 
         @Test
         @DisplayName("빈 제목으로 생성 시 예외 발생")
-        fun `빈 title로 ChatRoom 생성 시 IllegalArgumentException 발생`() {
-            // Arrange & Act & Assert
-            assertThatThrownBy {
-                ChatRoom(userId = 1L, title = "")
-            }.isInstanceOf(IllegalArgumentException::class.java)
-                .hasMessageContaining("title")
+        fun `빈 title로 ChatRoom 생성 시 예외`() {
+            assertThatThrownBy { ChatRoom(userId = 1L, title = "") }
+                .isInstanceOf(IllegalArgumentException::class.java)
         }
+    }
+}
+```
 
-        @Test
-        @DisplayName("100자 초과 제목으로 생성 시 예외 발생")
-        fun `100자 초과 title로 ChatRoom 생성 시 IllegalArgumentException 발생`() {
-            // Arrange
-            val longTitle = "가".repeat(101)
+### Java + JUnit5
 
-            // Act & Assert
-            assertThatThrownBy {
-                ChatRoom(userId = 1L, title = longTitle)
-            }.isInstanceOf(IllegalArgumentException::class.java)
-                .hasMessageContaining("100")
-        }
+```java
+@DisplayName("ChatRoom Entity 테스트")
+class ChatRoomTest {
+
+    @Nested
+    @DisplayName("Entity 생성")
+    class Creation {
 
         @Test
-        @DisplayName("100자 제목은 허용")
-        fun `100자 title로 ChatRoom 생성 시 성공`() {
+        @DisplayName("유효한 값으로 Entity 생성 시 성공")
+        void createChatRoom_withValidInput_succeeds() {
             // Arrange
-            val maxTitle = "가".repeat(100)
+            Long userId = 1L;
+            String title = "테스트 채팅방";
 
             // Act
-            val chatRoom = ChatRoom(userId = 1L, title = maxTitle)
+            ChatRoom chatRoom = new ChatRoom(userId, title);
 
             // Assert
-            assertThat(chatRoom.title).hasSize(100)
+            assertThat(chatRoom.getExternalId()).isNotNull();
+            assertThat(chatRoom.getTitle()).isEqualTo(title);
         }
     }
 
     @Nested
-    @DisplayName("Status 기본값")
-    inner class DefaultStatus {
+    @DisplayName("유효성 검증")
+    class Validation {
 
         @Test
-        @DisplayName("생성 시 기본 상태는 ACTIVE")
-        fun `ChatRoom 생성 시 status 기본값은 ACTIVE`() {
+        @DisplayName("빈 제목으로 생성 시 예외 발생")
+        void createChatRoom_withEmptyTitle_throwsException() {
+            assertThatThrownBy(() -> new ChatRoom(1L, ""))
+                .isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+}
+```
+
+### TypeScript + Jest
+
+```typescript
+describe('ChatRoom Entity', () => {
+  describe('Entity 생성', () => {
+    it('유효한 값으로 Entity 생성 시 성공', () => {
+      // Arrange
+      const userId = 1;
+      const title = '테스트 채팅방';
+
+      // Act
+      const chatRoom = new ChatRoom({ userId, title });
+
+      // Assert
+      expect(chatRoom.externalId).toBeDefined();
+      expect(chatRoom.title).toBe(title);
+    });
+  });
+
+  describe('유효성 검증', () => {
+    it('빈 제목으로 생성 시 예외 발생', () => {
+      expect(() => new ChatRoom({ userId: 1, title: '' }))
+        .toThrow('title');
+    });
+  });
+});
+```
+
+### Python + pytest
+
+```python
+import pytest
+from domain.chat.model import ChatRoom
+
+class TestChatRoom:
+    """ChatRoom Entity 테스트"""
+
+    class TestCreation:
+        """Entity 생성"""
+
+        def test_create_chatroom_with_valid_input_succeeds(self):
+            # Arrange
+            user_id = 1
+            title = "테스트 채팅방"
+
+            # Act
+            chat_room = ChatRoom(user_id=user_id, title=title)
+
+            # Assert
+            assert chat_room.external_id is not None
+            assert chat_room.title == title
+
+    class TestValidation:
+        """유효성 검증"""
+
+        def test_create_chatroom_with_empty_title_raises_error(self):
+            with pytest.raises(ValueError, match="title"):
+                ChatRoom(user_id=1, title="")
+```
+
+### Go + testing
+
+```go
+func TestChatRoom(t *testing.T) {
+    t.Run("Entity 생성", func(t *testing.T) {
+        t.Run("유효한 값으로 Entity 생성 시 성공", func(t *testing.T) {
+            // Arrange
+            userID := int64(1)
+            title := "테스트 채팅방"
+
             // Act
-            val chatRoom = ChatRoom(userId = 1L, title = "테스트")
+            chatRoom, err := NewChatRoom(userID, title)
 
             // Assert
-            assertThat(chatRoom.status).isEqualTo(ChatRoomStatus.ACTIVE)
-        }
-    }
+            assert.NoError(t, err)
+            assert.NotEmpty(t, chatRoom.ExternalID)
+            assert.Equal(t, title, chatRoom.Title)
+        })
+    })
+
+    t.Run("유효성 검증", func(t *testing.T) {
+        t.Run("빈 제목으로 생성 시 에러", func(t *testing.T) {
+            _, err := NewChatRoom(1, "")
+            assert.Error(t, err)
+        })
+    })
 }
 ```