feat: Slack AI 챗봇 구현

.env.example

@@ -42,6 +42,12 @@ OAUTH_APPLE_KEY_ID=your-apple-key-id
 OAUTH_APPLE_PRIVATE_KEY_PATH=/path/to/apple/private/key.p8
 OAUTH_APPLE_CLIENT_SECRET=your-apple-client-secret
 
-# Slack Webhooks (Optional)
+# Slack Configuration
+SLACK_SIGNING_SECRET=your-slack-signing-secret
 SLACK_WEBHOOK_ERROR=https://hooks.slack.com/services/YOUR/WEBHOOK/URL
 SLACK_WEBHOOK_EVENT=https://hooks.slack.com/services/YOUR/WEBHOOK/URL
+
+# Gemini AI Configuration
+GEMINI_PROJECT_ID=your-gcp-project-id
+GEMINI_LOCATION=us-central1
+GEMINI_MODEL=gemini-1.5-flash

build.gradle

@@ -70,6 +70,9 @@ dependencies {
     // notification
     implementation 'com.google.firebase:firebase-admin:9.2.0'
 
+    // Gemini AI
+    implementation 'com.google.cloud:google-cloud-vertexai:1.15.0'
+
     // test
     testImplementation 'org.springframework.boot:spring-boot-starter-test'
     testImplementation 'org.springframework.security:spring-security-test'

src/main/java/gg/agit/konect/domain/club/repository/ClubMemberRepository.java

@@ -190,4 +190,6 @@ long countByClubIdAndPosition(
 
     void deleteByUserId(Integer userId);
 
+    @Query("SELECT COUNT(cm) FROM ClubMember cm")
+    long countAll();
 }

src/main/java/gg/agit/konect/domain/club/repository/ClubRecruitmentRepository.java

@@ -30,4 +30,12 @@ default ClubRecruitment getByClubId(Integer clubId) {
         return findByClubId(clubId)
             .orElseThrow(() -> CustomException.of(NOT_FOUND_CLUB_RECRUITMENT));
     }
+
+    @Query("""
+        SELECT COUNT(cr)
+        FROM ClubRecruitment cr
+        WHERE cr.isAlwaysRecruiting = true
+           OR (cr.startAt <= CURRENT_TIMESTAMP AND cr.endAt >= CURRENT_TIMESTAMP)
+        """)
+    long countCurrentlyRecruiting();
 }

src/main/java/gg/agit/konect/domain/club/repository/ClubRepository.java

@@ -29,4 +29,7 @@ default Club getById(Integer id) {
     List<Club> findAll();
 
     Club save(Club club);
+
+    @Query("SELECT COUNT(c) FROM Club c")
+    long countAll();
 }

src/main/java/gg/agit/konect/domain/user/repository/UserRepository.java

@@ -143,4 +143,11 @@ List<User> findUserIdsByUniversityAndStudentYear(
         AND u.deletedAt IS NULL
         """)
     List<User> findAllByIdIn(@Param("ids") List<Integer> ids);
+
+    @Query("""
+        SELECT COUNT(u)
+        FROM User u
+        WHERE u.deletedAt IS NULL
+        """)
+    long countActiveUsers();
 }

src/main/java/gg/agit/konect/global/config/SecurityPaths.java

@@ -9,7 +9,8 @@ public final class SecurityPaths {
         "/swagger-ui.html",
         "/v3/api-docs/**",
         "/swagger-resources/**",
-        "/error"
+        "/error",
+        "/slack/events"
     };
 
     public static final String[] DENY_PATHS = {};

src/main/java/gg/agit/konect/infrastructure/gemini/client/GeminiClient.java

@@ -0,0 +1,121 @@
+package gg.agit.konect.infrastructure.gemini.client;
+
+import java.io.IOException;
+
+import org.springframework.stereotype.Component;
+
+import com.google.cloud.vertexai.VertexAI;
+import com.google.cloud.vertexai.api.GenerateContentResponse;
+import com.google.cloud.vertexai.generativeai.GenerativeModel;
+import com.google.cloud.vertexai.generativeai.ResponseHandler;
+
+import gg.agit.konect.infrastructure.gemini.config.GeminiProperties;
+import jakarta.annotation.PostConstruct;
+import jakarta.annotation.PreDestroy;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@Component
+public class GeminiClient {
+
+    private static final String INTENT_ANALYSIS_PROMPT = """
+        당신은 KONECT 서비스의 데이터 분석 AI입니다.
+        사용자의 질문을 분석하여 다음 중 하나의 쿼리 타입만 반환하세요.
+        반드시 아래 목록 중 하나의 값만 반환하고, 다른 텍스트는 포함하지 마세요.
+
+        가능한 쿼리 타입:
+        - USER_COUNT: 가입된 사용자 수, 회원 수, 유저 수 관련 질문
+        - CLUB_COUNT: 전체 동아리 수, 동아리 개수 관련 질문
+        - CLUB_RECRUITING_COUNT: 현재 모집 중인 동아리 수, 모집 현황 관련 질문
+        - CLUB_MEMBER_TOTAL_COUNT: 전체 동아리원 수, 동아리 멤버 총 인원 관련 질문
+        - UNKNOWN: 위 항목에 해당하지 않는 질문
+
+        예시:
+        - "가입된 사용자 수 알려줘" -> USER_COUNT
+        - "현재 모집 중인 동아리 몇개야?" -> CLUB_RECRUITING_COUNT
+        - "전체 동아리 수는?" -> CLUB_COUNT
+        - "동아리원이 총 몇명이야?" -> CLUB_MEMBER_TOTAL_COUNT
+        - "오늘 날씨 어때?" -> UNKNOWN
+        - "특정 사용자 이메일 알려줘" -> UNKNOWN
+
+        사용자 질문: %s
+
+        쿼리 타입:
+        """;
+
+    private static final String RESPONSE_GENERATION_PROMPT = """
+        당신은 KONECT 서비스의 친절한 AI 어시스턴트입니다.
+        아래 정보를 바탕으로 사용자에게 자연스럽고 친절한 한국어로 응답해주세요.
+        이모지를 적절히 사용하여 친근하게 답변해주세요.
+        응답은 간결하게 2-3문장으로 작성해주세요.
+
+        사용자 질문: %s
+        조회된 데이터: %s
+
+        응답:
+        """;
+
+    private final GeminiProperties geminiProperties;
+    private VertexAI vertexAI;
+    private GenerativeModel generativeModel;
+
+    public GeminiClient(GeminiProperties geminiProperties) {
+        this.geminiProperties = geminiProperties;
+    }
+
+    @PostConstruct
+    public void init() {
+        this.vertexAI = new VertexAI(
+            geminiProperties.projectId(),
+            geminiProperties.location()
+        );
+        this.generativeModel = new GenerativeModel(geminiProperties.model(), vertexAI);
+        log.info("GeminiClient 초기화 완료: project={}, location={}, model={}",
+            geminiProperties.projectId(),
+            geminiProperties.location(),
+            geminiProperties.model()
+        );
+    }
+
+    @PreDestroy
+    public void destroy() {
+        if (vertexAI != null) {
+            try {
+                vertexAI.close();
+                log.info("GeminiClient 리소스 해제 완료");
+            } catch (Exception e) {
+                log.warn("GeminiClient 리소스 해제 중 오류", e);
+            }
+        }
+    }
+
+    public String analyzeIntent(String userQuery) {
+        String prompt = String.format(INTENT_ANALYSIS_PROMPT, userQuery);
+        String result = callGemini(prompt);
+        if (result == null) {
+            return "UNKNOWN";
+        }
+        return result.trim().toUpperCase();
+    }
+
+    public String generateResponse(String userQuery, String data) {
+        String prompt = String.format(RESPONSE_GENERATION_PROMPT, userQuery, data);
+        String result = callGemini(prompt);
+        return result != null ? result : "응답을 생성할 수 없습니다.";
+    }
+
+    private String callGemini(String prompt) {
+        if (generativeModel == null) {
+            log.error("GenerativeModel이 초기화되지 않았습니다.");
+            return null;
+        }
+
+        try {
+            GenerateContentResponse response = generativeModel.generateContent(prompt);
+            return ResponseHandler.getText(response);
+        } catch (IOException e) {
+            log.error("Gemini API 호출 실패", e);
+            return null;
+        }
+    }
+}

src/main/java/gg/agit/konect/infrastructure/gemini/config/GeminiProperties.java

@@ -0,0 +1,12 @@
+package gg.agit.konect.infrastructure.gemini.config;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+@ConfigurationProperties(prefix = "gemini")
+public record GeminiProperties(
+    String projectId,
+    String location,
+    String model
+) {
+
+}

src/main/java/gg/agit/konect/infrastructure/slack/ai/SlackAIService.java

@@ -0,0 +1,113 @@
+package gg.agit.konect.infrastructure.slack.ai;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Service;
+
+import gg.agit.konect.infrastructure.gemini.client.GeminiClient;
+import gg.agit.konect.infrastructure.slack.client.SlackClient;
+import gg.agit.konect.infrastructure.slack.config.SlackProperties;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class SlackAIService {
+
+    private static final Pattern AI_PREFIX_PATTERN = Pattern.compile("^[Aa][Ii]\\)\\s*(.+)$");
+    private static final Pattern MENTION_PATTERN = Pattern.compile("^<@[^>]+>\\s*");
+    private static final String UNKNOWN = "UNKNOWN";
+
+    private final GeminiClient geminiClient;
+    private final StatisticsQueryExecutor queryExecutor;
+    private final SlackClient slackClient;
+    private final SlackProperties slackProperties;
+
+    public boolean isAIQuery(String text) {
+        if (text == null) {
+            return false;
+        }
+        return AI_PREFIX_PATTERN.matcher(text.trim()).matches();
+    }
+
+    public String extractQuery(String text) {
+        Matcher matcher = AI_PREFIX_PATTERN.matcher(text.trim());
+        if (matcher.matches()) {
+            return matcher.group(1).trim();
+        }
+        return text;
+    }
+
+    public String normalizeAppMentionText(String text) {
+        if (text == null) {
+            return null;
+        }
+        return MENTION_PATTERN.matcher(text).replaceFirst("").trim();
+    }
+
+    @Async
+    public void processAIQuery(String text) {
+        try {
+            String userQuery = extractQuery(text);
+
+            // 빈 질문은 처리하지 않음
+            if (userQuery == null || userQuery.isBlank()) {
+                log.debug("빈 질문으로 처리 중단");
+                String guidanceMessage = formatSlackResponse(
+                    "질문 내용이 비어있습니다. 예: `AI) 가입자 수 알려줘` 또는 `@봇이름 동아리 수는?`"
+                );
+                slackClient.sendMessage(guidanceMessage, slackProperties.webhooks().event());
+                return;
+            }
+
+            log.debug("AI 질문 처리 시작");
+
+            // 1. Gemini에게 의도 분석 요청
+            String queryType = geminiClient.analyzeIntent(userQuery);
+            log.debug("분석된 쿼리 타입: {}", queryType);
+
+            String response;
+
+            // 2. 지원하지 않는 질문인 경우
+            if (UNKNOWN.equals(queryType)) {
+                response = generateUnsupportedResponse(userQuery);
+            } else {
+                // 3. 안전한 통계 쿼리 실행
+                String data = queryExecutor.execute(queryType);
+
+                if (data == null) {
+                    response = generateUnsupportedResponse(userQuery);
+                } else {
+                    // 4. Gemini에게 자연어 응답 생성 요청
+                    response = geminiClient.generateResponse(userQuery, data);
+                }
+            }
+
+            log.debug("AI 응답 생성 완료");
+
+            // 5. Slack에 응답 전송
+            String slackMessage = formatSlackResponse(response);
+            slackClient.sendMessage(slackMessage, slackProperties.webhooks().event());
+
+        } catch (Exception e) {
+            log.error("AI 질문 처리 중 오류 발생", e);
+            String errorMessage = ":warning: 죄송합니다. 요청을 처리하는 중 오류가 발생했습니다.";
+            slackClient.sendMessage(errorMessage, slackProperties.webhooks().event());
+        }
+    }
+
+    private String generateUnsupportedResponse(String userQuery) {
+        return geminiClient.generateResponse(
+            userQuery,
+            "이 질문은 현재 지원하지 않는 유형입니다. "
+                + "사용자 수, 동아리 수, 모집 현황, 동아리원 수 등의 통계 질문을 해주세요."
+        );
+    }
+
+    private String formatSlackResponse(String response) {
+        return String.format(":robot_face: *AI 응답*\n%s", response);
+    }
+}