[AI] Kotlin Spring + Google AI Studio로 Github 코드 리뷰 봇 만들기

🛠️ 개발 환경

• Kotlin : 1.9.25
• Spring boot : 3.5.6
• Github

💨 요청 흐름

코드 리뷰가 진행되는 흐름은 다음과 같습니다.

PR → Github webhooks → Server → Google AI Studio → Get Github Apps(Bot) token → Github PR Comment

개인 Token을 사용하여 Comment를 남길 경우, 본인 계정으로 리뷰를 남기게 됩니다. 여러 명이서 작업하는 환경에서 오해의 여지가 발생할 수 있어, Github Apps를 사용해 Bot을 생성하여 해당 Bot의 Token을 발행해 리뷰를 남기게 됩니다.

🚨 주의 사항

이 포스팅은 EC2 인스턴스가 있으며, 본인의 도메인이 있다는 것을 가정하고 진행하며, Google AI Studio를 사용하기에 무료 서비스 사용 시, 입력한 내용과 생성된 응답은 Google의 제품 및 서비스 개선을 위해 사용될 수 있으니 주의하시길 바랍니다.

 

프리티어와 Google AI Studio에 결제 정보를 입력하지 않은 경우 과금 우려는 없습니다.

 

무작정 따라하는 것보단, 글을 훑어 본 뒤, 본인에게 필요한 내용인지 확인 후 따라하시길 추천드립니다. 또한, 개발 과정 및 리뷰 흐름을 정리하기 위한 포스팅이므로, 모든 코드가 포스팅에 포함되지 않습니다.

 

전체 코드가 필요한 경우, 리포지토리를 참고해주세요. 리팩터링 등으로 인해 블로그 포스팅과 실제 개발물이 차이가 생길 수 있는 점 유의해주세요. 궁금한 점이 있다면 댓글 또는 Issue에 남겨주시면 감사하겠습니다!

 

이 포스팅은 블로그 내 코드 가독성을 위해 공식 컨벤션과 다르게, 일부 린트를 조정한 부분이 있으니 참고해주세요.

⚙️ 설정 방법

이 프로젝트는 yaml 파일을 따로 .gitignore에 등록하지 않습니다. 때문에 각 변수에 해당하는 값들은 모두 Environment variables에서 관리하게 됩니다. env 파일을 만들어서 관리해도 무방합니다.

 

@param:Value("...") 코드가 포함된 경우, 해당 변수를 IntelliJ 환경 변수에 추가해주어야 합니다.

Run/Debug Configurations → Modify options → Environment variables

환경 변수를 설정하는 방법은 다음 사진과 같습니다.

 

 

환경 변수에 추가할 때마다 Secret을 미리 추가해두는 것이 좋습니다.

Repository → Security → Actions → New repository secret

프로젝트 의존성 세팅

주요 dependencies는 다음과 같습니다.

dependencies {
    // Github Apps 토큰 발행 관련 라이브러리
    implementation("io.jsonwebtoken:jjwt-api:0.11.5")  
    runtimeOnly("io.jsonwebtoken:jjwt-impl:0.11.5")  
    runtimeOnly("io.jsonwebtoken:jjwt-jackson:0.11.5")  

    // Google Gemini 라이브러리
    implementation("com.google.genai:google-genai:1.0.0")  

    implementation("com.fasterxml.jackson.module:jackson-module-kotlin")  

    // Coroutine 라이브러리
    implementation("io.projectreactor.kotlin:reactor-kotlin-extensions")  
    implementation("org.jetbrains.kotlin:kotlin-reflect")  
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-reactor") 
}

application.yaml에는 다음과 같은 정보가 필요합니다. 다른 방법으로 관리해도 무방합니다.

app:  
  github:  
    app:  
      app-id: ${APP_ID}  
      installation-id: ${APP_INSTALLATION_ID}  
      private-key: ${APP_PEM}  
    webhook:  
      secret-key: ${WEBHOOK_SECRET}  
    api:  
      token: ${API_TOKEN_GITHUB}  
  google:  
    api-key: ${GEMINI_API_KEY}

Github Webhooks 생성

Repository Settings 탭에 들어가 Add webook을 눌러 생성해줍니다.

Type	Content
Payload URL	웹 훅이 발생했을 때, 요청을 보낼 URL
Content type	Payload URL에 보낼 데이터의 Content type
Secret	유추하기 어려운 임의의 UUID
SSL verification	본인의 도메인에 https를 적용했다면 Enable 선택
Trigger	Let me select individual events를 눌러 Pull requests 체크

이 과정을 마치면 PR을 생성할 때, 본인의 EC2 인스턴스에 올라가있는 서버에 웹 훅을 보내게 됩니다.

Controller

Webhook 검증을 위해 GitHub에서 발급받은 Secret 값을 환경 변수(WEBHOOK_SECRET)로 등록합니다.

 

기본적인 틀은 다음과 같습니다. 밑에서 설명할 단순한 코드 조각들은 net 함수 내부 구현입니다. 그 외의 경우 Controller 코드가 아닌 다른 파일입니다.

@RestController  
class CodeReviewController(  
    @param:Value("\${app.github.webhook.secret-key}")
    private val secret: String,  
    private val codeReviewService: CodeReviewService  
) {
    @PostMapping("/api/code/review")  
    suspend fun net(  
        @RequestHeader("X-GitHub-Event") event: String,  
        @RequestHeader("X-Hub-Signature-256") sig256: String?,  
        @RequestBody rawBody: ByteArray  
    ): ResponseEntity<String> {  
        return ResponseEntity.ok("Request completed")  
    }  

    private fun unauthorized(  
        message: String  
    ) = ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(message)  
}

GithubSignature validation

Webhook 요청 시 기본적인 데이터가 모두 들어왔는지 확인하여, 위조 여부를 우선 판별합니다.

if (sig256 == null) {  
    logger.warn("Missing signature header for GitHub webhook")  
    return unauthorized("Missing signature")  
}  

if (!GithubSignature.isValid(sig256, secret, rawBody)) {  
    logger.warn("Invalid signature detected from GitHub webhook")  
    return unauthorized("Invalid signature")  
}

요청 본문(payload)과 미리 설정한 비밀 키(secret)를 이용해 HMAC-SHA256 서명을 생성하고, GitHub가 보낸 서명(X-Hub-Signature-256)과 상수 시간 비교(constant-time comparison) 방식으로 일치 여부를 검사합니다.

자세한 내용은 Webhook 유효성 검사 공식 문서를 참고해주세요.

object GithubSignature {  
    fun isValid(
        signatureHeader: String?, 
        secret: String, 
        payload: ByteArray
    ): Boolean {  
        if (signatureHeader.isNullOrBlank()) return false  
        val expected = sign256(secret, payload)  
        return constantTimeEquals(expected, signatureHeader)  
    }  

    private fun sign256(
        secret: String, 
        payload: ByteArray
    ): String {  
        ...
    }  

    private fun constantTimeEquals(a: String, b: String): Boolean {  
        ...
    }  
}

Payload parsing

GitHub Webhook의 JSON 본문에서 필요한 데이터만 추출하기 위해 DTO를 정의합니다. @JsonIgnoreProperties(ignoreUnknown = true)를 사용해 불필요한 필드는 자동으로 무시합니다.

val payload = parsePayload(rawBody)

@JsonIgnoreProperties(ignoreUnknown = true)  
data class GithubPayload(  
    val action: String,  
    val number: String,  
    val pull_request: PullRequestPayload  
)  

@JsonIgnoreProperties(ignoreUnknown = true)  
data class PullRequestPayload(  
    val url: String,  
    val head: PullRequestHeadPayload  
) {  
    private val _urls = url.removePrefix("https://").split("/")  
    val owner = _urls[2]  
    val repo = _urls[3]  
    val prNumber = _urls[5]  
}  

@JsonIgnoreProperties(ignoreUnknown = true)  
data class PullRequestHeadPayload(  
    val sha: String  
)  

val mapper = jacksonObjectMapper()  

fun parsePayload(rawBody: ByteArray): GithubPayload {  
    return mapper.readValue(rawBody)  
}

Request review

이제, payload에 필요한 정보를 받아왔으니, pull_request이고, opened 상태인 경우에 리뷰 요청을 보냅니다.

val action = GithubActionType(payload.action)  
logger.info("payload = {}, action = {}", payload, action)  

// PR 생성 시에만 리뷰 진행  
when (event) {  
    "pull_request" -> when (GithubActionType(payload.action)) {  
        GithubActionType.OPENED -> codeReviewService.review(payload)  
        else -> logger.info("Ignored pull_request event: ${payload.action}")  
    }  
    else -> logger.debug("Unhandled GitHub event: $event")  
}

enum class GithubActionType(val value: String) {  
    ASSIGNED("assigned"),  
    // 일부 타입 중략
    OPENED("opened"),
    ;  

    companion object {  
        operator fun invoke(value: String) = entries.find { it.value == value }  
    }  
}

Service

기본적인 틀은 다음과 같습니다. 아래에 설명할 세부 구현은 review 함수 내부 로직입니다. 이 포스팅에서는 구조화된 동시성이 아닌, 단순 코루틴 스코프 기반으로 구현했습니다.

@Service  
class CodeReviewService {
    private val scope = CoroutineScope(Dispatchers.IO)  

    fun review(payload: GithubPayload) {  

    }  
}

PR 코드 정보 가져오기

PR에 올라온 코드들의 정보를 받옵니다. 이 과정에서 repo에 대한 접근 권한을 가진 GitHub Personal Access Token이 필요합니다.

val diff = payload.pull_request.run {  
    githubDiffClient.getPrDiff(owner, repo, prNumber)  
}
val parts = GithubDiffUtils.splitDiffByFile(diff)

@Service  
class GithubDiffClient(  
    @param:Value("\${app.github.api.token}") private val token: String,  
) {  
    private val client = WebClient.builder()  
        .baseUrl("https://api.github.com")  
        .defaultHeader("Accept", "application/vnd.github.v3.diff")  
        .build()  

    fun getPrDiff(  
        owner: String,  
        repo: String,  
        prNumber: String  
    ): String = client.get()  
        .uri("/repos/$owner/$repo/pulls/$prNumber")  
        .header("Authorization", "Bearer $token")  
        .retrieve()  
        .bodyToMono(String::class.java)  
        .block()!!
}

가져온 데이터의 hunk를 분석합니다. 이 때, 해당 파일(filePath), 변경 사항(content), 마지막 라인(line) 정보를 저장합니다.

object GithubDiffUtils {  
    data class FileDiff(  
        val filePath: String,  
        val content: String,  
        val line: Int  
    )

    private fun findLastChangedLine(diffContent: String): Int {  
        ...
    }  

    fun splitDiffByFile(
        diff: String
    ): List<FileDiff> = diff.split("diff --git")  
        .drop(1)  
        .mapNotNull { chunk ->  
            ...
            FileDiff(filePath, content, lastChangedLine)  
        }  
}

Gemini에 코드 리뷰 요청

parts.forEach { part ->  
    scope.launch {  
        try {  
            val prompt = "```diff\\n${part.content}\\n```"  

            val review = googleGeminiClient.chat(prompt)

            githubReviewClient.addReviewComment(
                GithubReviewDto(payload.pull_request, part, review)
            )
        } catch (e: Exception) {  
            logger.error("[Review Failed] file = ${part.filePath}", e)  
        }  
    }  
}

이제, part에 담긴 content를 기반으로 Gemini에게 코드 리뷰 요청을 보냅니다. 여기서 app.google.api-key는 Google AI Studio에서 발급 받은 값을 의미합니다.

 

SYSTEM_PROMPT는 본인이 리뷰를 원하는 프롬프트를 입력해주면 됩니다. 예를 들어, 역할을 지정해주고, 어떤 부분 위주로 코드 리뷰를 해달라는 등에 대한 프롬프트를 입력해주면 됩니다.

@Component  
class GoogleGeminiClient(  
    @param:Value("\${app.google.api-key}") val apiKey: String  
) {  
    private val instruction = Content.builder()  
        .role("system")  
        .parts(  
            listOf(  
                Part.builder()  
                    .text(SYSTEM_PROMPT)  
                    .build()  
            )  
        )  
        .build()  

    private val think = ThinkingConfig.builder()  
        .thinkingBudget(500)  
        .build()  

    private val clientPool = ConcurrentHashMap<String, Client>()  

    private fun getClient(filePath: String): Client {  
        return clientPool.computeIfAbsent(filePath) {  
            Client.builder().apiKey(apiKey).build()  
        }  
    }  

    suspend fun chat(filePath: String, prompt: String): String? = withContext(Dispatchers.IO) {  
        val client = getClient(filePath)  
        try {  
            client.models.generateContentStream(  
                MODEL, prompt,  
                GenerateContentConfig.builder()  
                    .systemInstruction(instruction)  
                    .thinkingConfig(think)  
                    .build()  
            ).use { stream ->  
                buildString {  
                    for (response in stream) append(response.text())  
                }  
            }        
        } catch (e: Exception) {  
            null  
        } finally {  
            clientPool.remove(filePath)  
        }  
    }  
}

PR 코멘트 남기기

코멘트를 남길 때, 개인 Token을 사용할 경우, 본인의 프로필로 리뷰가 달립니다. 여러 명이서 작업하는 경우, 오해의 소지가 있기 때문에, Github Apps를 통해 Bot을 만들어 리뷰를 달도록 합니다.

@Service  
class GithubReviewClient(  
    private val tokenProvider: GithubAppTokenProvider  
) {  
    data class ReviewCommentRequest(  
        val body: String,  
        val path: String,  
        val commit_id: String,  
        val subject_type: String = "file"  
    )  

    val client = WebClient.builder()  
        .baseUrl("https://api.github.com")  
        .defaultHeader("Accept", "application/vnd.github+json")  
        .defaultHeader("Authorization", "Bearer ${tokenProvider.getInstallationToken()}")  
        .build()  

    suspend fun addReviewComment(  
        dto: GithubReviewDto  
    ) {  
        val uri = dto.payload.run {  
            "/repos/$owner/$repo/pulls/$prNumber/comments"  
        }  

        client.post()  
            .uri(uri)  
            .bodyValue(dto.toReviewCommentRequest())  
            .retrieve()  
            .bodyToMono(String::class.java)  
            .block()  
    }  
}

Github Apps 생성

New Github App에 들어가 새로운 App을 생성해줍니다. 이 App은 리뷰 요청 시 사용할 토큰 발급용으로만 사용되므로 필수 항목들만 간략하게 입력을 해줍니다.

 

이미 체크가 되어있는 항목은 모두 해제하고, Homepage URL 또한 아무 주소나 입력해도 무방합니다. Permissions 부분에 Repository permissions 중 Pull requests만 Read and write로 설정해주면 됩니다.

 

App을 생성한 후, 다음 항목들을 가져와 환경 변수와 Repository Secret에 추가해줍니다.

• App ID
• Installation ID
  • 모든 설정 후, Install App 탭에 들어가서 설치
  • 설치 후 톱니바퀴 모양을 눌러 Integrations에 진입
  • URL의 숫자가 Installation ID를 의미
    • https://github.com/settings/installations/123456 형태임
• Private key(아래 내용에 따라서 적용)

 

 

Generate a private key를 발급받으면, pem 파일이 다운로드 될텐데, 이 파일은 다음과 같이 시작합니다. -----BEGIN RSA PRIVATE KEY-----

 

이 키의 형식은 PKCS#1인데, Java 계열에서 기본적으로 제공하는 것은 PKCS#8이다. 때문에, 다음 명령어를 사용해 PKCS#1를 PKCS#8 키로 변환해줍니다.

openssl pkcs8 -topk8 -inform PEM -outform PEM -in private-key.pem -out private-key-pkcs8.pem -nocrypt

이 명령어를 사용하면 파일 헤더가 -----BEGIN PRIVATE KEY-----로 바뀐 것을 볼 수 있을 것이다. 이제 이 값을 환경 변수와 secret에 추가해주어야 하는데, secret에는 그대로 넣어도 되지만, 환경 변수에는 여러 줄을 유지해서 넣을 수 없기 때문에 각 라인 끝에 \n를 포함하여 한 줄로 만들어서 넣어주면 됩니다.

@Component  
class GithubAppTokenProvider(  
    @param:Value("\${app.github.app.app-id}") private val appId: String,  
    @param:Value("\${app.github.app.installation-id}") private val installationId: String,  
    @param:Value("\${app.github.app.private-key}") private val appPem: String  
) {  
    @Volatile private var cachedToken: String? = null  
    @Volatile private var expiresAt: Instant? = null  

    private val privateKey = run {  
        val pem = appPem.replace("\\n", "\n")  
            .replace("-----BEGIN PRIVATE KEY-----", "")  
            .replace("-----END PRIVATE KEY-----", "")  
            .replace("\\s+".toRegex(), "")  

        val keySpec = PKCS8EncodedKeySpec(Base64.getDecoder().decode(pem))  
        KeyFactory.getInstance("RSA").generatePrivate(keySpec)  
    }  

    private fun generateJwt(): String {  
        val now = Instant.now()  
        return Jwts.builder()  
            .setIssuer(appId)
            .setIssuedAt(Date.from(now))  
            .setExpiration(Date.from(now.plusSeconds(9 * 60)))
            .signWith(privateKey, SignatureAlgorithm.RS256)  
            .compact()  
    }  

    fun getInstallationToken(): String {  
        val now = Instant.now()  
        if (cachedToken != null && expiresAt?.isAfter(now.plusSeconds(30)) == true) {  
            return cachedToken!!
        }  

        val jwt = generateJwt()  
        val resp = WebClient.builder()  
            .baseUrl("https://api.github.com")  
            .defaultHeader("Authorization", "Bearer $jwt")  
            .defaultHeader("Accept", "application/vnd.github+json")  
            .build()  
            .post()  
            .uri("/app/installations/$installationId/access_tokens")  
            .retrieve()  
            .bodyToMono(Map::class.java)  
            .block()!!  

        cachedToken = resp["token"] as String  
        expiresAt = Instant.parse(resp["expires_at"] as String)  
        return cachedToken!!  
    }  
}

이 과정까지 완료되면, Pull Request가 생성될 때 자동으로 Gemini가 diff를 분석하고, Github App 계정으로 리뷰 코멘트를 남기게 됩니다.

 

🤔 회고

모든 내용을 정리하면 좋을 것 같은데, 전체적인 흐름만 담은게 조금은 아쉬운 것 같다. 파일 하나하나에 많은 내용이 있어, 역할을 더 분리하도록 리팩터링이 필요할 것 같다.