feat: add jacoco reports (#13)

Author: eschizoid

README.md

@@ -1,4 +1,4 @@
-# Model Context Protocol Code Analysis Server
+# 🤖 Model Context Protocol Code Analysis Server
 
 A Kotlin server application that analyzes GitHub repositories using AI models through the Model Context Protocol (MCP).
 
@@ -8,7 +8,6 @@ A Kotlin server application that analyzes GitHub repositories using AI models th
 - Extract code structure and relationships
 - Process code using Model Context Protocol
 - Generate detailed insights and summaries
-- Functional architecture with immutable data classes
 - Multiple server modes (stdio, SSE)
 
 ## Getting Started
@@ -17,7 +16,7 @@ A Kotlin server application that analyzes GitHub repositories using AI models th
 
 - JDK 23 or higher
 - Kotlin 1.9.x
-- Gradle 8.0 or higher
+- Gradle 8.14 or higher
 - [Ollama](https://github.com/ollama/ollama) 3.2 or higher (for model API)
 - [MCP Inspector](https://github.com/modelcontextprotocol/inspector) (for model context protocol)
 
@@ -42,6 +41,27 @@ A Kotlin server application that analyzes GitHub repositories using AI models th
   npx @modelcontextprotocol/inspector
   ```
 
+5. You can access the MCP Inspector at `http://127.0.0.1:6274/` and configure the `Arguments` to start the server:
+
+![Connect](https://raw.githubusercontent.com/eschizo/mcp-github-code-analyzer/main/img/mcp_connect_server.png)
+
+Use the following arguments:
+
+  ```bash
+  ~/mcp-github-code-analyzer/build/libs/mcp-github-code-analyzer-0.1.0-SNAPSHOT.jar --stdio
+  ```
+
+6. Click `Connect` to start the MCP Server.
+
+7. Then you can click the tab `Tools` to discover the available tools. The Tool `analyze-repository` should be listed
+   and ready to be used. Click on the `analyze-repository` tool to see its details and parameters:
+
+![Tools Tab](https://raw.githubusercontent.com/eschizo/mcp-github-code-analyzer/main/img/mcp_tools_tab.png)
+
+8. Finally, capture the `repoUrl` and `branch` parameters and click `Run Tool` to start the analysis:
+
+![Run Tool](https://raw.githubusercontent.com/eschizo/mcp-github-code-analyzer/main/img/mcp_inspector_run_tool.png)
+
 ### Configuration
 
 The application uses environment variables for configuration:
@@ -82,11 +102,11 @@ This server implements the Model Context Protocol (MCP) and provides the followi
 
 Required parameters:
 
-- repoUrl: GitHub repository URL (e.g., https://github.com/owner/repo)
+- `repoUrl`: GitHub repository URL (e.g., https://github.com/owner/repo)
 
 Optional parameters:
 
-- branch: Branch to analyze (default: main)
+- `branch`: Branch to analyze (default: main)
 
 ## Project Structure
 

img/mcp_inspector_connect_server.png

@@ -36,13 +36,22 @@ data class CodeAnalyzer(
       .map { file ->
         val relativePath = file.absolutePath.substring(repoDir.absolutePath.length + 1)
         val lang = getLanguageFromExtension(file.extension)
-        val safeContent = file.readLines().joinToString("\n")
-        "---\nFile: $relativePath\n~~~$lang\n$safeContent\n~~~"
+        val content = file.readLines().joinToString("\n")
+        """---
+          |File: $relativePath
+          |~~~$lang
+          |$content
+          |~~~"""
+          .trimIndent()
       }
       .toList()
       .also { snippets ->
         logger.info("Collected ${snippets.size} code snippets from ${repoDir.absolutePath}")
-        logger.debug("Snippets Found:\n${snippets.joinToString("\n")}")
+        logger.debug(
+          """Snippets Found:
+          |${snippets.joinToString("\n")}"""
+            .trimIndent()
+        )
       }
 
   /**

img/mcp_inspector_run_tool.png

@@ -5,6 +5,7 @@ import io.mockk.every
 import io.mockk.mockk
 import io.mockk.verify
 import java.io.File
+import java.lang.Exception
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.test.runTest
 import org.junit.jupiter.api.BeforeEach
@@ -41,7 +42,15 @@ class RepositoryAnalysisServiceTest {
     val branch = "main"
     val clonedRepo = File(tempDir, "repo")
     val readmeContent = "# Test Repository"
-    val codeSnippets = listOf("---\nFile: src/Main.kt\n~~~kotlin\nfun main() {}\n~~~")
+    val codeSnippets =
+      listOf(
+        """---
+          |File: src/Main.kt
+          |~~~kotlin
+          |fun main() {}
+          |~~~"""
+          .trimIndent()
+      )
     val modelResponse = "Repository Analysis: This is a simple Kotlin project"
     val insightsPrompt = "insights prompt"
     val summaryPrompt = "summary prompt"
@@ -63,113 +72,136 @@ class RepositoryAnalysisServiceTest {
     verify { codeAnalyzer.findReadmeFile(clonedRepo) }
     verify { codeAnalyzer.collectAllCodeSnippets(clonedRepo) }
     verify { runBlocking { modelContextService.generateResponse(any()) } }
+  }
 
-    @Test
-    fun `analyzeRepository should handle git errors`() = runTest {
-      // Arrange
-      val repoUrl = "https://github.com/user/repo"
-      val branch = "main"
+  @Test
+  fun `analyzeRepository should handle git errors`() = runTest {
+    // Arrange
+    val repoUrl = "https://github.com/user/repo"
+    val branch = "main"
 
-      every { gitService.cloneRepository(repoUrl, branch) } throws RuntimeException("Git error")
+    every { gitService.cloneRepository(repoUrl, branch) } throws Exception("Error cloning repository")
 
-      // Act & Assert
-      val exception = assertThrows<RuntimeException> { repositoryAnalysisService.analyzeRepository(repoUrl, branch) }
-      assert(exception.message?.contains("Error cloning repository") == true)
-    }
+    // Act & Assert
+    val exception = assertThrows<Exception> { repositoryAnalysisService.analyzeRepository(repoUrl, branch) }
+    assert(exception.message?.contains("Error cloning repository") == true)
+  }
 
-    @Test
-    fun `analyzeRepository should handle code analysis errors`() {
-      // Arrange
-      val repoUrl = "https://github.com/user/repo"
-      val branch = "main"
-      val clonedRepo = File(tempDir, "repo")
+  @Test
+  fun `analyzeRepository should handle code analysis errors`() {
+    // Arrange
+    val repoUrl = "https://github.com/user/repo"
+    val branch = "main"
+    val clonedRepo = File(tempDir, "repo")
 
-      every { gitService.cloneRepository(repoUrl, branch) } returns clonedRepo
-      every { codeAnalyzer.findReadmeFile(clonedRepo) } throws RuntimeException("Analysis error")
+    every { gitService.cloneRepository(repoUrl, branch) } returns clonedRepo
+    every { codeAnalyzer.findReadmeFile(clonedRepo) } throws Exception("Error analyzing repository code")
 
-      // Act & Assert
-      val exception =
-        assertThrows<RuntimeException> { runBlocking { repositoryAnalysisService.analyzeRepository(repoUrl, branch) } }
+    // Act & Assert
+    val exception =
+      assertThrows<Exception> { runBlocking { repositoryAnalysisService.analyzeRepository(repoUrl, branch) } }
 
-      assert(exception.message?.contains("Error analyzing repository code") == true)
-    }
+    assert(exception.message?.contains("Error analyzing repository code") == true)
+  }
 
-    @Test
-    fun `analyzeRepository should handle model service errors`() {
-      // Arrange
-      val repoUrl = "https://github.com/user/repo"
-      val branch = "main"
-      val clonedRepo = File(tempDir, "repo")
-      val readmeContent = "# Test Repository"
-      val codeSnippets = listOf("---\nFile: src/Main.kt\n~~~kotlin\nfun main() {}\n~~~")
-
-      every { gitService.cloneRepository(repoUrl, branch) } returns clonedRepo
-      every { codeAnalyzer.findReadmeFile(clonedRepo) } returns readmeContent
-      every { codeAnalyzer.collectAllCodeSnippets(clonedRepo) } returns codeSnippets
-      coEvery { modelContextService.generateResponse(any()) } throws RuntimeException("Model error")
-
-      // Act & Assert
-      val exception =
-        assertThrows<RuntimeException> { runBlocking { repositoryAnalysisService.analyzeRepository(repoUrl, branch) } }
-
-      assert(exception.message?.contains("Error generating repository analysis") == true)
-    }
+  @Test
+  fun `analyzeRepository should handle model service errors`() {
+    // Arrange
+    val repoUrl = "https://github.com/user/repo"
+    val branch = "main"
+    val clonedRepo = File(tempDir, "repo")
+    val readmeContent = "# Test Repository"
+    val codeSnippets =
+      listOf(
+        """---
+          |File: src/Main.kt
+          |~~~kotlin
+          |fun main() {}
+          |~~~"""
+          .trimIndent()
+      )
 
-    @Test
-    fun `analyzeRepository should handle empty code snippets`() = runTest {
-      // Arrange
-      val repoUrl = "https://github.com/user/repo"
-      val branch = "main"
-      val clonedRepo = File(tempDir, "repo")
-      val readmeContent = "# Test Repository"
-      val emptySnippets = emptyList<String>()
-      val modelResponse = "Repository Analysis: No code files found"
-
-      every { gitService.cloneRepository(repoUrl, branch) } returns clonedRepo
-      every { codeAnalyzer.findReadmeFile(clonedRepo) } returns readmeContent
-      every { codeAnalyzer.collectAllCodeSnippets(clonedRepo) } returns emptySnippets
-      coEvery { modelContextService.generateResponse(any()) } returns modelResponse
-
-      // Act
-      val result = repositoryAnalysisService.analyzeRepository(repoUrl, branch)
-
-      // Assert
-      assert(result == modelResponse)
-      verify { codeAnalyzer.collectAllCodeSnippets(clonedRepo) }
-      verify {
-        runBlocking {
-          modelContextService.generateResponse(
-            match { prompt -> prompt.contains("No code files found") || prompt.contains("0 code snippets") }
-          )
-        }
-      }
+    every { gitService.cloneRepository(repoUrl, branch) } returns clonedRepo
+    every { codeAnalyzer.findReadmeFile(clonedRepo) } returns readmeContent
+    every { codeAnalyzer.collectAllCodeSnippets(clonedRepo) } returns codeSnippets
+    coEvery { modelContextService.generateResponse(any()) } throws Exception("Error analyzing repository")
+
+    // Act & Assert
+    val exception =
+      assertThrows<Exception> { runBlocking { repositoryAnalysisService.analyzeRepository(repoUrl, branch) } }
+
+    assert(exception.message?.contains("Error analyzing repository") == true)
+  }
+
+  @Test
+  fun `analyzeRepository should handle empty code snippets`() = runTest {
+    // Arrange
+    val repoUrl = "https://github.com/user/repo"
+    val branch = "main"
+    val clonedRepo = File(tempDir, "repo")
+    val readmeContent = "# Test Repository"
+    val emptySnippets = emptyList<String>()
+    val insightsPrompt = "Insights prompt"
+    val summaryPrompt = "Summary prompt"
+    val modelResponse = "Repository Analysis"
+
+    every { gitService.cloneRepository(repoUrl, branch) } returns clonedRepo
+    every { codeAnalyzer.findReadmeFile(clonedRepo) } returns readmeContent
+    every { codeAnalyzer.analyzeStructure(clonedRepo) } returns emptyMap()
+    every { codeAnalyzer.collectAllCodeSnippets(clonedRepo) } returns emptySnippets
+    every { modelContextService.buildInsightsPrompt(readmeContent) } returns insightsPrompt
+    every { modelContextService.buildSummaryPrompt(any(), any(), any()) } returns summaryPrompt
+    coEvery { modelContextService.generateResponse(any()) } returns modelResponse
+
+    // Act
+    val result = repositoryAnalysisService.analyzeRepository(repoUrl, branch)
+
+    // Assert
+    assert(result == modelResponse)
+    verify { codeAnalyzer.collectAllCodeSnippets(clonedRepo) }
+    verify {
+      runBlocking { modelContextService.generateResponse("Insights prompt") }
+      runBlocking { modelContextService.generateResponse("Summary prompt") }
     }
+  }
+
+  @Test
+  fun `analyzeRepository should handle missing README`() = runTest {
+    // Arrange
+    val repoUrl = "https://github.com/user/repo"
+    val branch = "main"
+    val clonedRepo = File(tempDir, "repo")
+    val noReadme = "No README content available."
+    val codeSnippets =
+      listOf(
+        """"---
+           |File: src/Main.kt
+           |~~~kotlin
+           |fun main() {}
+           |~~~"""
+          .trimIndent()
+      )
+    val modelResponse = "Repository Analysis: Kotlin project without README"
+    val insightsPrompt = "No README content available"
+    val summaryPrompt = "Summary prompt"
+
+    every { gitService.cloneRepository(repoUrl, branch) } returns clonedRepo
+    every { codeAnalyzer.findReadmeFile(clonedRepo) } returns noReadme
+    every { codeAnalyzer.analyzeStructure(clonedRepo) } returns emptyMap()
+    every { codeAnalyzer.collectAllCodeSnippets(clonedRepo) } returns codeSnippets
+    every { modelContextService.buildInsightsPrompt(noReadme) } returns insightsPrompt
+    every { modelContextService.buildSummaryPrompt(any(), any(), any()) } returns summaryPrompt
+    coEvery { modelContextService.generateResponse(any()) } returns modelResponse
 
-    @Test
-    fun `analyzeRepository should handle missing README`() = runTest {
-      // Arrange
-      val repoUrl = "https://github.com/user/repo"
-      val branch = "main"
-      val clonedRepo = File(tempDir, "repo")
-      val noReadme = "No README content available."
-      val codeSnippets = listOf("---\nFile: src/Main.kt\n~~~kotlin\nfun main() {}\n~~~")
-      val modelResponse = "Repository Analysis: Kotlin project without README"
-
-      every { gitService.cloneRepository(repoUrl, branch) } returns clonedRepo
-      every { codeAnalyzer.findReadmeFile(clonedRepo) } returns noReadme
-      every { codeAnalyzer.collectAllCodeSnippets(clonedRepo) } returns codeSnippets
-      coEvery { modelContextService.generateResponse(any()) } returns modelResponse
-
-      // Act
-      val result = repositoryAnalysisService.analyzeRepository(repoUrl, branch)
-
-      // Assert
-      assert(result == modelResponse)
-      verify { codeAnalyzer.findReadmeFile(clonedRepo) }
-      verify {
-        runBlocking {
-          modelContextService.generateResponse(match { prompt -> prompt.contains("No README content available") })
-        }
+    // Act
+    val result = repositoryAnalysisService.analyzeRepository(repoUrl, branch)
+
+    // Assert
+    assert(result == modelResponse)
+    verify { codeAnalyzer.findReadmeFile(clonedRepo) }
+    verify {
+      runBlocking {
+        modelContextService.generateResponse(match { prompt -> prompt.contains("No README content available") })
       }
     }
   }