Merge feature/event into develop

Event-AI Kafka 통신 개선 및 타입 헤더 불일치 문제 해결

주요 변경사항:
- event-service KafkaConfig: JsonSerializer로 변경, 타입 헤더 비활성화
- ai-service application.yml: 타입 헤더 사용 안 함, 기본 타입 지정
- AIEventGenerationJobMessage: region, targetAudience, budget 필드 추가
- AiRecommendationRequest: region, targetAudience, budget 필드 추가
- AIJobKafkaProducer: 객체 직접 전송으로 변경 (이중 직렬화 문제 해결)
- AIJobKafkaConsumer: 양방향 통신 이슈로 비활성화 (.bak)
- EventService: Kafka producer 호출 시 새 필드 전달

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

ai-service/src/main/resources/application.yml

@@ -28,6 +28,8 @@ spring:
       value-deserializer: org.springframework.kafka.support.serializer.JsonDeserializer
       properties:
         spring.json.trusted.packages: "*"
+        spring.json.use.type.headers: false
+        spring.json.value.default.type: com.kt.ai.kafka.message.AIJobMessage
         max.poll.records: 10
         session.timeout.ms: 30000
     listener:

common/src/main/java/com/kt/event/common/exception/ErrorCode.java

@@ -40,8 +40,10 @@ public enum ErrorCode {
     EVENT_001("EVENT_001", "이벤트를 찾을 수 없습니다"),
     EVENT_002("EVENT_002", "유효하지 않은 상태 전환입니다"),
     EVENT_003("EVENT_003", "필수 데이터가 누락되었습니다"),
-    EVENT_004("EVENT_004", "이벤트 생성에 실패했습니다"),
-    EVENT_005("EVENT_005", "이벤트 수정 권한이 없습니다"),
+    EVENT_004("EVENT_004", "유효하지 않은 eventId 형식입니다"),
+    EVENT_005("EVENT_005", "이미 존재하는 eventId입니다"),
+    EVENT_006("EVENT_006", "이벤트 생성에 실패했습니다"),
+    EVENT_007("EVENT_007", "이벤트 수정 권한이 없습니다"),
 
     // Job 에러 (JOB_XXX)
     JOB_001("JOB_001", "Job을 찾을 수 없습니다"),

content-service/src/main/java/com/kt/event/content/biz/service/RegenerateImageService.java

@@ -155,12 +155,12 @@ public class RegenerateImageService implements RegenerateImageUseCase {
     private String generateImage(String prompt, com.kt.event.content.biz.domain.Platform platform) {
         try {
             // Mock 모드일 경우 Mock 데이터 반환
-            if (mockEnabled) {
-                log.info("[MOCK] 이미지 재생성 요청 (실제 API 호출 없음): prompt={}, platform={}", prompt, platform);
-                String mockUrl = generateMockImageUrl(platform);
-                log.info("[MOCK] 이미지 재생성 완료: url={}", mockUrl);
-                return mockUrl;
-            }
+//            if (mockEnabled) {
+//                log.info("[MOCK] 이미지 재생성 요청 (실제 API 호출 없음): prompt={}, platform={}", prompt, platform);
+//                String mockUrl = generateMockImageUrl(platform);
+//                log.info("[MOCK] 이미지 재생성 완료: url={}", mockUrl);
+//                return mockUrl;
+//            }
 
             int width = platform.getWidth();
             int height = platform.getHeight();

content-service/src/main/java/com/kt/event/content/biz/service/StableDiffusionImageGenerator.java

@@ -192,12 +192,12 @@ public class StableDiffusionImageGenerator implements GenerateImagesUseCase {
     private String generateImage(String prompt, Platform platform) {
         try {
             // Mock 모드일 경우 Mock 데이터 반환
-            if (mockEnabled) {
-                log.info("[MOCK] 이미지 생성 요청 (실제 API 호출 없음): prompt={}, platform={}", prompt, platform);
-                String mockUrl = generateMockImageUrl(platform);
-                log.info("[MOCK] 이미지 생성 완료: url={}", mockUrl);
-                return mockUrl;
-            }
+//            if (mockEnabled) {
+//                log.info("[MOCK] 이미지 생성 요청 (실제 API 호출 없음): prompt={}, platform={}", prompt, platform);
+//                String mockUrl = generateMockImageUrl(platform);
+//                log.info("[MOCK] 이미지 생성 완료: url={}", mockUrl);
+//                return mockUrl;
+//            }
 
             // 플랫폼별 이미지 크기 설정 (Platform enum에서 가져옴)
             int width = platform.getWidth();

event-service/src/main/java/com/kt/event/eventservice/application/dto/kafka/AIEventGenerationJobMessage.java

@@ -6,7 +6,6 @@ import lombok.Data;
 import lombok.NoArgsConstructor;
 
 import java.time.LocalDateTime;
-import java.util.List;
 
 /**
  * AI 이벤트 생성 작업 메시지 DTO
@@ -35,72 +34,42 @@ public class AIEventGenerationJobMessage {
      */
     private String eventId;
 
+    /**
+     * 이벤트 목적
+     * - "신규 고객 유치"
+     * - "재방문 유도"
+     * - "매출 증대"
+     * - "브랜드 인지도 향상"
+     */
+    private String objective;
+
+    /**
+     * 업종 (storeCategory와 동일)
+     */
+    private String industry;
+
+    /**
+     * 지역 (시/구/동)
+     */
+    private String region;
+
     /**
      * 매장명
      */
     private String storeName;
 
     /**
-     * 매장 업종
+     * 목표 고객층 (선택)
      */
-    private String storeCategory;
+    private String targetAudience;
 
     /**
-     * 매장 설명
+     * 예산 (원) (선택)
      */
-    private String storeDescription;
+    private Integer budget;
 
     /**
-     * 이벤트 목적
+     * 요청 시각
      */
-    private String objective;
-
-    /**
-     * 작업 상태 (PENDING, PROCESSING, COMPLETED, FAILED)
-     */
-    private String status;
-
-    /**
-     * AI 추천 결과 데이터
-     */
-    private AIRecommendationData aiRecommendation;
-
-    /**
-     * 에러 메시지 (실패 시)
-     */
-    private String errorMessage;
-
-    /**
-     * 작업 생성 일시
-     */
-    private LocalDateTime createdAt;
-
-    /**
-     * 작업 완료/실패 일시
-     */
-    private LocalDateTime completedAt;
-
-    /**
-     * AI 추천 데이터 내부 클래스
-     */
-    @Data
-    @Builder
-    @NoArgsConstructor
-    @AllArgsConstructor
-    public static class AIRecommendationData {
-
-        private String eventTitle;
-
-        private String eventDescription;
-
-        private String eventType;
-
-        private List<String> targetKeywords;
-
-        private List<String> recommendedBenefits;
-
-        private String startDate;
-
-        private String endDate;
-    }
+    private LocalDateTime requestedAt;
 }

event-service/src/main/java/com/kt/event/eventservice/application/dto/request/AiRecommendationRequest.java

@@ -24,11 +24,24 @@ import lombok.NoArgsConstructor;
 @Schema(description = "AI 추천 요청")
 public class AiRecommendationRequest {
 
+    @NotNull(message = "이벤트 목적은 필수입니다.")
+    @Schema(description = "이벤트 목적", required = true, example = "신규 고객 유치")
+    private String objective;
+
     @NotNull(message = "매장 정보는 필수입니다.")
     @Valid
     @Schema(description = "매장 정보", required = true)
     private StoreInfo storeInfo;
 
+    @Schema(description = "지역 정보", example = "서울특별시 강남구")
+    private String region;
+
+    @Schema(description = "타겟 고객층", example = "20-30대 직장인")
+    private String targetAudience;
+
+    @Schema(description = "예산 (원)", example = "500000")
+    private Integer budget;
+
     /**
      * 매장 정보
      */

event-service/src/main/java/com/kt/event/eventservice/application/dto/request/SelectObjectiveRequest.java

@@ -19,6 +19,9 @@ import lombok.NoArgsConstructor;
 @Builder
 public class SelectObjectiveRequest {
 
+    @NotBlank(message = "이벤트 ID는 필수입니다.")
+    private String eventId;
+
     @NotBlank(message = "이벤트 목적은 필수입니다.")
     private String objective;
 }

event-service/src/main/java/com/kt/event/eventservice/application/service/EventIdGenerator.java

@@ -23,38 +23,25 @@ public class EventIdGenerator {
     private static final int RANDOM_LENGTH = 8;
 
     /**
-     * 이벤트 ID 생성
+     * 이벤트 ID 생성 (백엔드용)
      *
-     * @param storeId 상점 ID (최대 15자 권장)
+     * 참고: 현재는 프론트엔드에서 eventId를 생성하므로 이 메서드는 거의 사용되지 않습니다.
+     *
+     * @param storeId 상점 ID
      * @return 생성된 이벤트 ID
-     * @throws IllegalArgumentException storeId가 null이거나 비어있는 경우
      */
     public String generate(String storeId) {
+        // 기본값 처리
         if (storeId == null || storeId.isBlank()) {
-            throw new IllegalArgumentException("storeId는 필수입니다");
+            storeId = "unknown";
         }
 
-        // storeId 길이 검증 (전체 길이 50자 제한)
-        // TODO: 프로덕션에서는 storeId 길이 제한 필요
-        // if (storeId.length() > 15) {
-        //     throw new IllegalArgumentException("storeId는 15자 이하여야 합니다");
-        // }
-
         String timestamp = LocalDateTime.now().format(TIMESTAMP_FORMATTER);
         String randomPart = generateRandomPart();
 
         // 형식: EVT-{storeId}-{timestamp}-{random}
-        // 예상 길이: 3 + 1 + 15 + 1 + 14 + 1 + 8 = 43자 (최대)
         String eventId = String.format("%s-%s-%s-%s", PREFIX, storeId, timestamp, randomPart);
 
-        // 길이 검증
-        if (eventId.length() > 50) {
-            throw new IllegalStateException(
-                String.format("생성된 eventId 길이(%d)가 50자를 초과했습니다: %s",
-                    eventId.length(), eventId)
-            );
-        }
-
         return eventId;
     }
 
@@ -72,7 +59,14 @@ public class EventIdGenerator {
     }
 
     /**
-     * eventId 형식 검증
+     * eventId 기본 검증
+     *
+     * 최소한의 검증만 수행합니다:
+     * - null/empty 체크
+     * - 길이 제한 체크 (VARCHAR(50) 제약)
+     *
+     * 프론트엔드에서 생성한 eventId를 신뢰하며,
+     * DB의 PRIMARY KEY 제약조건으로 중복을 방지합니다.
      *
      * @param eventId 검증할 이벤트 ID
      * @return 유효하면 true, 아니면 false
@@ -82,32 +76,11 @@ public class EventIdGenerator {
             return false;
         }
 
-        // EVT-로 시작하는지 확인
-        if (!eventId.startsWith(PREFIX + "-")) {
-            return false;
-        }
-
-        // 길이 검증
+        // 길이 검증 (DB VARCHAR(50) 제약)
         if (eventId.length() > 50) {
             return false;
         }
 
-        // 형식 검증: EVT-{storeId}-{14자리숫자}-{8자리영숫자}
-        String[] parts = eventId.split("-");
-        if (parts.length != 4) {
-            return false;
-        }
-
-        // timestamp 부분이 14자리 숫자인지 확인
-        if (parts[2].length() != 14 || !parts[2].matches("\\d{14}")) {
-            return false;
-        }
-
-        // random 부분이 8자리 영숫자인지 확인
-        if (parts[3].length() != 8 || !parts[3].matches("[a-z0-9]{8}")) {
-            return false;
-        }
-
         return true;
     }
 }

event-service/src/main/java/com/kt/event/eventservice/application/service/EventService.java

@@ -55,17 +55,20 @@ public class EventService {
      *
      * @param userId 사용자 ID
      * @param storeId 매장 ID
-     * @param request 목적 선택 요청
+     * @param request 목적 선택 요청 (eventId 포함)
      * @return 생성된 이벤트 응답
      */
     @Transactional
     public EventCreatedResponse createEvent(String userId, String storeId, SelectObjectiveRequest request) {
-        log.info("이벤트 생성 시작 - userId: {}, storeId: {}, objective: {}",
-                 userId, storeId, request.getObjective());
+        log.info("이벤트 생성 시작 - userId: {}, storeId: {}, eventId: {}, objective: {}",
+                 userId, storeId, request.getEventId(), request.getObjective());
 
-        // eventId 생성
-        String eventId = eventIdGenerator.generate(storeId);
-        log.info("생성된 eventId: {}", eventId);
+        String eventId = request.getEventId();
+
+        // 동일한 eventId가 이미 존재하는지 확인
+        if (eventRepository.findByEventId(eventId).isPresent()) {
+            throw new BusinessException(ErrorCode.EVENT_005);
+        }
 
         // 이벤트 엔티티 생성
         Event event = Event.builder()
@@ -305,17 +308,35 @@ public class EventService {
      * AI 추천 요청
      *
      * @param userId 사용자 ID
-     * @param eventId 이벤트 ID
-     * @param request AI 추천 요청
+     * @param eventId 이벤트 ID (프론트엔드에서 생성한 ID)
+     * @param request AI 추천 요청 (objective 포함)
      * @return Job 접수 응답
      */
     @Transactional
     public JobAcceptedResponse requestAiRecommendations(String userId, String eventId, AiRecommendationRequest request) {
-        log.info("AI 추천 요청 - userId: {}, eventId: {}", userId, eventId);
+        log.info("AI 추천 요청 - userId: {}, eventId: {}, objective: {}",
+                 userId, eventId, request.getObjective());
 
-        // 이벤트 조회 및 권한 확인
+        // 이벤트 조회 또는 생성
         Event event = eventRepository.findByEventIdAndUserId(eventId, userId)
-            .orElseThrow(() -> new BusinessException(ErrorCode.EVENT_001));
+            .orElseGet(() -> {
+                log.info("이벤트가 존재하지 않아 새로 생성합니다 - eventId: {}", eventId);
+
+                // storeId 추출 (eventId 형식: EVT-{storeId}-{timestamp}-{random})
+                String storeId = request.getStoreInfo().getStoreId();
+
+                // 새 이벤트 생성
+                Event newEvent = Event.builder()
+                    .eventId(eventId)
+                    .userId(userId)
+                    .storeId(storeId)
+                    .objective(request.getObjective())
+                    .eventName("") // 초기에는 비어있음, AI 추천 후 설정
+                    .status(EventStatus.DRAFT)
+                    .build();
+
+                return eventRepository.save(newEvent);
+            });
 
         // DRAFT 상태 확인
         if (!event.isModifiable()) {
@@ -340,9 +361,11 @@ public class EventService {
             userId,
             eventId,
             request.getStoreInfo().getStoreName(),
-            request.getStoreInfo().getCategory(),
-            request.getStoreInfo().getDescription(),
-            event.getObjective()
+            request.getStoreInfo().getCategory(),      // industry
+            request.getRegion(),                        // region
+            event.getObjective(),                       // objective
+            request.getTargetAudience(),                // targetAudience
+            request.getBudget()                         // budget
         );
 
         log.info("AI 추천 요청 완료 - jobId: {}", job.getJobId());

event-service/src/main/java/com/kt/event/eventservice/application/service/JobIdGenerator.java

@@ -82,7 +82,11 @@ public class JobIdGenerator {
     }
 
     /**
-     * jobId 형식 검증
+     * jobId 기본 검증
+     *
+     * 최소한의 검증만 수행합니다:
+     * - null/empty 체크
+     * - 길이 제한 체크 (VARCHAR(50) 제약)
      *
      * @param jobId 검증할 Job ID
      * @return 유효하면 true, 아니면 false
@@ -92,32 +96,11 @@ public class JobIdGenerator {
             return false;
         }
 
-        // JOB-로 시작하는지 확인
-        if (!jobId.startsWith(PREFIX + "-")) {
-            return false;
-        }
-
-        // 길이 검증
+        // 길이 검증 (DB VARCHAR(50) 제약)
         if (jobId.length() > 50) {
             return false;
         }
 
-        // 형식 검증: JOB-{type}-{timestamp}-{8자리영숫자}
-        String[] parts = jobId.split("-");
-        if (parts.length != 4) {
-            return false;
-        }
-
-        // timestamp 부분이 숫자인지 확인
-        if (!parts[2].matches("\\d+")) {
-            return false;
-        }
-
-        // random 부분이 8자리 영숫자인지 확인
-        if (parts[3].length() != 8 || !parts[3].matches("[a-z0-9]{8}")) {
-            return false;
-        }
-
         return true;
     }
 }

event-service/src/main/java/com/kt/event/eventservice/config/KafkaConfig.java

@@ -37,7 +37,7 @@ public class KafkaConfig {
 
     /**
      * Kafka Producer 설정
-     * Producer에서 JSON 문자열을 보내므로 StringSerializer 사용
+     * Producer에서 객체를 직접 보내므로 JsonSerializer 사용
      *
      * @return ProducerFactory 인스턴스
      */
@@ -46,7 +46,10 @@ public class KafkaConfig {
         Map<String, Object> config = new HashMap<>();
         config.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
         config.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
-        config.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
+        config.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, JsonSerializer.class);
+
+        // JSON 직렬화 시 타입 정보를 헤더에 추가하지 않음 (마이크로서비스 간 DTO 클래스 불일치 방지)
+        config.put(JsonSerializer.ADD_TYPE_INFO_HEADERS, false);
 
         // Producer 성능 최적화 설정
         config.put(ProducerConfig.ACKS_CONFIG, "all");

event-service/src/main/java/com/kt/event/eventservice/config/SecurityConfig.java

@@ -72,6 +72,7 @@ public class SecurityConfig {
     /**
      * CORS 설정
      * 개발 환경에서 프론트엔드(localhost:3000)의 요청을 허용합니다.
+     * 쿠키 기반 인증을 위한 설정이 포함되어 있습니다.
      *
      * @return CorsConfigurationSource CORS 설정 소스
      */
@@ -82,7 +83,10 @@ public class SecurityConfig {
         // 허용할 Origin (개발 환경)
         configuration.setAllowedOrigins(Arrays.asList(
             "http://localhost:3000",
-            "http://127.0.0.1:3000"
+            "http://127.0.0.1:3000",
+            "http://localhost:8081",
+            "http://localhost:8082",
+            "http://localhost:8083"
         ));
 
         // 허용할 HTTP 메서드
@@ -90,7 +94,7 @@ public class SecurityConfig {
             "GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"
         ));
 
-        // 허용할 헤더
+        // 허용할 헤더 (쿠키 포함)
         configuration.setAllowedHeaders(Arrays.asList(
             "Authorization",
             "Content-Type",
@@ -98,19 +102,21 @@ public class SecurityConfig {
             "Accept",
             "Origin",
             "Access-Control-Request-Method",
-            "Access-Control-Request-Headers"
+            "Access-Control-Request-Headers",
+            "Cookie"
         ));
 
-        // 인증 정보 포함 허용
+        // 인증 정보 포함 허용 (쿠키 전송을 위해 필수)
         configuration.setAllowCredentials(true);
 
         // Preflight 요청 캐시 시간 (초)
         configuration.setMaxAge(3600L);
 
-        // 노출할 응답 헤더
+        // 노출할 응답 헤더 (쿠키 포함)
         configuration.setExposedHeaders(Arrays.asList(
             "Authorization",
-            "Content-Type"
+            "Content-Type",
+            "Set-Cookie"
         ));
 
         UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();

event-service/src/main/java/com/kt/event/eventservice/domain/repository/EventRepository.java

@@ -21,6 +21,11 @@ import java.util.Optional;
 @Repository
 public interface EventRepository extends JpaRepository<Event, String> {
 
+    /**
+     * 이벤트 ID로 조회
+     */
+    Optional<Event> findByEventId(String eventId);
+
     /**
      * 사용자 ID와 이벤트 ID로 조회
      */

event-service/src/main/java/com/kt/event/eventservice/infrastructure/kafka/AIJobKafkaConsumer.java.bak

@@ -28,7 +28,8 @@ import org.springframework.transaction.annotation.Transactional;
  * @since 2025-10-29
  */
 @Slf4j
-@Component
+// TODO: 별도 response 토픽 사용 시 활성화
+// @Component
 @RequiredArgsConstructor
 public class AIJobKafkaConsumer {
 

event-service/src/main/java/com/kt/event/eventservice/infrastructure/kafka/AIJobKafkaProducer.java

@@ -1,6 +1,5 @@
 package com.kt.event.eventservice.infrastructure.kafka;
 
-import com.fasterxml.jackson.databind.ObjectMapper;
 import com.kt.event.eventservice.application.dto.kafka.AIEventGenerationJobMessage;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -27,7 +26,6 @@ import java.util.concurrent.CompletableFuture;
 public class AIJobKafkaProducer {
 
     private final KafkaTemplate<String, Object> kafkaTemplate;
-    private final ObjectMapper objectMapper;
 
     @Value("${app.kafka.topics.ai-event-generation-job:ai-event-generation-job}")
     private String aiEventGenerationJobTopic;
@@ -39,29 +37,34 @@ public class AIJobKafkaProducer {
      * @param userId 사용자 ID
      * @param eventId 이벤트 ID (EVT-{storeId}-{yyyyMMddHHmmss}-{random8})
      * @param storeName 매장명
-     * @param storeCategory 매장 업종
-     * @param storeDescription 매장 설명
+     * @param industry 업종 (매장 카테고리)
+     * @param region 지역
      * @param objective 이벤트 목적
+     * @param targetAudience 목표 고객층 (선택)
+     * @param budget 예산 (선택)
      */
     public void publishAIGenerationJob(
             String jobId,
             String userId,
             String eventId,
             String storeName,
-            String storeCategory,
-            String storeDescription,
-            String objective) {
+            String industry,
+            String region,
+            String objective,
+            String targetAudience,
+            Integer budget) {
 
         AIEventGenerationJobMessage message = AIEventGenerationJobMessage.builder()
             .jobId(jobId)
             .userId(userId)
             .eventId(eventId)
             .storeName(storeName)
-            .storeCategory(storeCategory)
-            .storeDescription(storeDescription)
+            .industry(industry)
+            .region(region)
             .objective(objective)
-            .status("PENDING")
-            .createdAt(LocalDateTime.now())
+            .targetAudience(targetAudience)
+            .budget(budget)
+            .requestedAt(LocalDateTime.now())
             .build();
 
         publishMessage(message);
@@ -74,11 +77,9 @@ public class AIJobKafkaProducer {
      */
     public void publishMessage(AIEventGenerationJobMessage message) {
         try {
-            // JSON 문자열로 변환
-            String jsonMessage = objectMapper.writeValueAsString(message);
-
+            // 객체를 직접 전송 (JsonSerializer가 자동으로 직렬화)
             CompletableFuture<SendResult<String, Object>> future =
-                kafkaTemplate.send(aiEventGenerationJobTopic, message.getJobId(), jsonMessage);
+                kafkaTemplate.send(aiEventGenerationJobTopic, message.getJobId(), message);
 
             future.whenComplete((result, ex) -> {
                 if (ex == null) {

test_ai_request.json

@@ -0,0 +1,12 @@
+{
+  "objective": "increase_sales",
+  "region": "Seoul Gangnam",
+  "targetAudience": "Office workers in 20-30s",
+  "budget": 500000,
+  "storeInfo": {
+    "storeId": "str_20250124_001",
+    "storeName": "Woojin Korean BBQ",
+    "category": "Restaurant",
+    "description": "Fresh Korean beef restaurant"
+  }
+}

tools/run-intellij-service-profile.py

@@ -0,0 +1,303 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Tripgen Service Runner Script
+Reads execution profiles from {service-name}/.run/{service-name}.run.xml and runs services accordingly.
+
+Usage:
+    python run-config.py <service-name>
+
+Examples:
+    python run-config.py user-service
+    python run-config.py location-service
+    python run-config.py trip-service
+    python run-config.py ai-service
+"""
+
+import os
+import sys
+import subprocess
+import xml.etree.ElementTree as ET
+from pathlib import Path
+import argparse
+
+
+def get_project_root():
+    """Find project root directory"""
+    current_dir = Path(__file__).parent.absolute()
+    while current_dir.parent != current_dir:
+        if (current_dir / 'gradlew').exists() or (current_dir / 'gradlew.bat').exists():
+            return current_dir
+        current_dir = current_dir.parent
+    
+    # If gradlew not found, assume parent directory of develop as project root
+    return Path(__file__).parent.parent.absolute()
+
+
+def parse_run_configurations(project_root, service_name=None):
+    """Parse run configuration files from .run directories"""
+    configurations = {}
+    
+    if service_name:
+        # Parse specific service configuration
+        run_config_path = project_root / service_name / '.run' / f'{service_name}.run.xml'
+        if run_config_path.exists():
+            config = parse_single_run_config(run_config_path, service_name)
+            if config:
+                configurations[service_name] = config
+        else:
+            print(f"[ERROR] Cannot find run configuration: {run_config_path}")
+    else:
+        # Find all service directories
+        service_dirs = ['user-service', 'location-service', 'trip-service', 'ai-service']
+        for service in service_dirs:
+            run_config_path = project_root / service / '.run' / f'{service}.run.xml'
+            if run_config_path.exists():
+                config = parse_single_run_config(run_config_path, service)
+                if config:
+                    configurations[service] = config
+    
+    return configurations
+
+
+def parse_single_run_config(config_path, service_name):
+    """Parse a single run configuration file"""
+    try:
+        tree = ET.parse(config_path)
+        root = tree.getroot()
+        
+        # Find configuration element
+        config = root.find('.//configuration[@type="GradleRunConfiguration"]')
+        if config is None:
+            print(f"[WARNING] No Gradle configuration found in {config_path}")
+            return None
+        
+        # Extract environment variables
+        env_vars = {}
+        env_option = config.find('.//option[@name="env"]')
+        if env_option is not None:
+            env_map = env_option.find('map')
+            if env_map is not None:
+                for entry in env_map.findall('entry'):
+                    key = entry.get('key')
+                    value = entry.get('value')
+                    if key and value:
+                        env_vars[key] = value
+        
+        # Extract task names
+        task_names = []
+        task_names_option = config.find('.//option[@name="taskNames"]')
+        if task_names_option is not None:
+            task_list = task_names_option.find('list')
+            if task_list is not None:
+                for option in task_list.findall('option'):
+                    value = option.get('value')
+                    if value:
+                        task_names.append(value)
+        
+        if env_vars or task_names:
+            return {
+                'env_vars': env_vars,
+                'task_names': task_names,
+                'config_path': str(config_path)
+            }
+        
+        return None
+    
+    except ET.ParseError as e:
+        print(f"[ERROR] XML parsing error in {config_path}: {e}")
+        return None
+    except Exception as e:
+        print(f"[ERROR] Error reading {config_path}: {e}")
+        return None
+
+
+def get_gradle_command(project_root):
+    """Return appropriate Gradle command for OS"""
+    if os.name == 'nt':  # Windows
+        gradle_bat = project_root / 'gradlew.bat'
+        if gradle_bat.exists():
+            return str(gradle_bat)
+        return 'gradle.bat'
+    else:  # Unix-like (Linux, macOS)
+        gradle_sh = project_root / 'gradlew'
+        if gradle_sh.exists():
+            return str(gradle_sh)
+        return 'gradle'
+
+
+def run_service(service_name, config, project_root):
+    """Run service"""
+    print(f"[START] Starting {service_name} service...")
+    
+    # Set environment variables
+    env = os.environ.copy()
+    for key, value in config['env_vars'].items():
+        env[key] = value
+        print(f"   [ENV] {key}={value}")
+    
+    # Prepare Gradle command
+    gradle_cmd = get_gradle_command(project_root)
+    
+    # Execute tasks
+    for task_name in config['task_names']:
+        print(f"\n[RUN] Executing: {task_name}")
+        
+        cmd = [gradle_cmd, task_name]
+        
+        try:
+            # Execute from project root directory
+            process = subprocess.Popen(
+                cmd,
+                cwd=project_root,
+                env=env,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                universal_newlines=True,
+                bufsize=1,
+                encoding='utf-8',
+                errors='replace'
+            )
+            
+            print(f"[CMD] Command: {' '.join(cmd)}")
+            print(f"[DIR] Working directory: {project_root}")
+            print("=" * 50)
+            
+            # Real-time output
+            for line in process.stdout:
+                print(line.rstrip())
+            
+            # Wait for process completion
+            process.wait()
+            
+            if process.returncode == 0:
+                print(f"\n[SUCCESS] {task_name} execution completed")
+            else:
+                print(f"\n[FAILED] {task_name} execution failed (exit code: {process.returncode})")
+                return False
+                
+        except KeyboardInterrupt:
+            print(f"\n[STOP] Interrupted by user")
+            process.terminate()
+            return False
+        except Exception as e:
+            print(f"\n[ERROR] Execution error: {e}")
+            return False
+    
+    return True
+
+
+def list_available_services(configurations):
+    """List available services"""
+    print("[LIST] Available services:")
+    print("=" * 40)
+    
+    for service_name, config in configurations.items():
+        if config['task_names']:
+            print(f"  [SERVICE] {service_name}")
+            if 'config_path' in config:
+                print(f"     +-- Config: {config['config_path']}")
+            for task in config['task_names']:
+                print(f"     +-- Task: {task}")
+            print(f"     +-- {len(config['env_vars'])} environment variables")
+        print()
+
+
+def main():
+    """Main function"""
+    parser = argparse.ArgumentParser(
+        description='Tripgen Service Runner Script',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    python run-config.py user-service
+    python run-config.py location-service
+    python run-config.py trip-service
+    python run-config.py ai-service
+    python run-config.py --list
+        """
+    )
+    
+    parser.add_argument(
+        'service_name',
+        nargs='?',
+        help='Service name to run'
+    )
+    
+    parser.add_argument(
+        '--list', '-l',
+        action='store_true',
+        help='List available services'
+    )
+    
+    args = parser.parse_args()
+    
+    # Find project root
+    project_root = get_project_root()
+    print(f"[INFO] Project root: {project_root}")
+    
+    # Parse run configurations
+    print("[INFO] Reading run configuration files...")
+    configurations = parse_run_configurations(project_root)
+    
+    if not configurations:
+        print("[ERROR] No execution configurations found")
+        return 1
+    
+    print(f"[INFO] Found {len(configurations)} execution configurations")
+    
+    # List services request
+    if args.list:
+        list_available_services(configurations)
+        return 0
+    
+    # If service name not provided
+    if not args.service_name:
+        print("\n[ERROR] Please provide service name")
+        list_available_services(configurations)
+        print("Usage: python run-config.py <service-name>")
+        return 1
+    
+    # Find service
+    service_name = args.service_name
+    
+    # Try to parse specific service configuration if not found
+    if service_name not in configurations:
+        print(f"[INFO] Trying to find configuration for '{service_name}'...")
+        configurations = parse_run_configurations(project_root, service_name)
+        
+    if service_name not in configurations:
+        print(f"[ERROR] Cannot find '{service_name}' service")
+        list_available_services(configurations)
+        return 1
+    
+    config = configurations[service_name]
+    
+    if not config['task_names']:
+        print(f"[ERROR] No executable tasks found for '{service_name}' service")
+        return 1
+    
+    # Execute service
+    print(f"\n[TARGET] Starting '{service_name}' service execution")
+    print("=" * 50)
+    
+    success = run_service(service_name, config, project_root)
+    
+    if success:
+        print(f"\n[COMPLETE] '{service_name}' service started successfully!")
+        return 0
+    else:
+        print(f"\n[FAILED] Failed to start '{service_name}' service")
+        return 1
+
+
+if __name__ == '__main__':
+    try:
+        exit_code = main()
+        sys.exit(exit_code)
+    except KeyboardInterrupt:
+        print("\n[STOP] Interrupted by user")
+        sys.exit(1)
+    except Exception as e:
+        print(f"\n[ERROR] Unexpected error occurred: {e}")
+        sys.exit(1)