code clean up (#19)

refactor: improve exception handling and code readability across multiple files

refactor: clean up code formatting and improve readability across multiple files

refactor: update import statements for improved clarity and consistency in test files

refactor: improve code readability by formatting log messages and restructuring conditional statements

* test: add regression tests for Credits endpoint and modal dialog behavior

* refactor: update Detekt plugin version and improve code readability in multiple files

Author: DimazzzZ

CHANGELOG.md

@@ -59,7 +59,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 #### IDE Support Extension
 - **JetBrains IDE 2025.3.X Support** - Extended compatibility for newest IDE versions including Rider
-- **Deprecated API Updates** - Replaced deprecated PluginDescriptor.isEnabled() with PluginManagerCore.isPluginEnabled()
+- **Deprecated API Updates** - Replaced deprecated PluginDescriptor.isEnabled() with PluginManagerCore.isDisabled() (negated)
 - **Backward Compatibility** - Seamless upgrade path for existing users from 2023.2+
 
 #### Build System Updates

build.gradle.kts

@@ -1,8 +1,10 @@
+import org.jetbrains.intellij.tasks.PublishPluginTask
+
 plugins {
     id("java")
-    id("org.jetbrains.kotlin.jvm") version "1.9.25"
+    id("org.jetbrains.kotlin.jvm") version "2.1.10"
     id("org.jetbrains.intellij") version "1.17.4"
-    id("io.gitlab.arturbosch.detekt") version "1.23.4"
+    id("io.gitlab.arturbosch.detekt") version "1.23.7"
 }
 
 group = project.findProperty("pluginGroup") ?: "org.zhavoronkov"
@@ -23,6 +25,9 @@ dependencies {
     implementation("com.squareup.okhttp3:okhttp:4.11.0")
     implementation("com.google.code.gson:gson:2.10.1")
 
+    // Use IntelliJ's bundled coroutines library to avoid classloader conflicts
+    compileOnly("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0")
+
     // Embedded HTTP server for AI Assistant integration
     implementation("org.eclipse.jetty:jetty-server:11.0.18")
     implementation("org.eclipse.jetty:jetty-servlet:11.0.18")
@@ -34,12 +39,13 @@ dependencies {
     testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.9.2")
     testImplementation("org.mockito:mockito-core:5.7.0")
     testImplementation("org.mockito:mockito-junit-jupiter:5.7.0")
+    testImplementation("org.mockito.kotlin:mockito-kotlin:5.1.0")
     testImplementation("com.squareup.okhttp3:mockwebserver:4.11.0")
     testImplementation("org.assertj:assertj-core:3.24.2")
 
 
     // Detekt plugins
-    detektPlugins("io.gitlab.arturbosch.detekt:detekt-formatting:1.23.4")
+    detektPlugins("io.gitlab.arturbosch.detekt:detekt-formatting:1.23.7")
 }
 
 // Configure IntelliJ Plugin
@@ -58,6 +64,13 @@ detekt {
     baseline = file("$projectDir/config/detekt/baseline.xml")
 }
 
+// Configure publishing token for publishPlugin task
+val publishPluginTask = tasks.named<PublishPluginTask>("publishPlugin")
+publishPluginTask.configure {
+    val publishToken = System.getenv("PUBLISH_TOKEN") ?: project.findProperty("publishToken") as String?
+    publishToken?.let { token.set(it) }
+}
+
 // Configure Detekt SARIF reporting task
 tasks.register<io.gitlab.arturbosch.detekt.Detekt>("detektSarif") {
     description = "Runs detekt and generates SARIF report for GitHub Code Scanning"

config/detekt/detekt.yml

@@ -947,7 +947,7 @@ formatting:
     autoCorrect: true
   NoWildcardImports:
     active: true
-    packagesToUseImportOnDemandProperty: 'java.util.*,kotlinx.android.synthetic.**'
+    packagesToUseImportOnDemandProperty: 'java.util.*,kotlinx.android.synthetic.**,kotlinx.coroutines.**,com.intellij.ui.dsl.builder.**,com.intellij.openapi.ui.popup.**'
   NullableTypeSpacing:
     active: true
     autoCorrect: true

docs/AI_ASSISTANT_TECHNICAL_GUIDE.md

@@ -218,12 +218,11 @@ PluginLogger.Service.debug("[AI Assistant] Integration status: ...")
 ```kotlin
 private fun checkAIAssistantInstalled(): Boolean {
     return try {
-        val pluginManager = com.intellij.ide.plugins.PluginManagerCore.getPlugins()
-        val aiPlugin = pluginManager.find { 
-            it.pluginId.idString == "com.intellij.ml.llm" 
-        }
-        PluginLogger.Settings.debug("AI Assistant plugin: $aiPlugin, enabled: ${aiPlugin?.isEnabled}")
-        aiPlugin != null && aiPlugin.isEnabled
+        val pluginId = com.intellij.openapi.extensions.PluginId.getId("com.intellij.ml.llm")
+        val aiPlugin = com.intellij.ide.plugins.PluginManagerCore.getPlugin(pluginId)
+        val isEnabled = aiPlugin != null && !com.intellij.ide.plugins.PluginManagerCore.isDisabled(pluginId)
+        PluginLogger.Settings.debug("AI Assistant plugin: $aiPlugin, enabled: $isEnabled")
+        isEnabled
     } catch (e: Exception) {
         PluginLogger.Settings.debug("Could not check AI Assistant plugin status: ${e.message}")
         false

gradle.properties

@@ -26,13 +26,13 @@ platformVersion = 2024.1.6
 platformPlugins =
 
 # Gradle Releases -> https://github.com/gradle/gradle/releases
-gradleVersion = 8.14
+gradleVersion = 8.9
 
 # Opt-out flag for bundling Kotlin standard library -> https://jb.gg/intellij-platform-kotlin-stdlib
 kotlin.stdlib.default.dependency = false
 
 # Enable Gradle Configuration Cache -> https://docs.gradle.org/current/userguide/configuration_cache.html
-org.gradle.configuration-cache = true
+org.gradle.configuration-cache = false
 
 # Enable Gradle Build Cache -> https://docs.gradle.org/current/userguide/build_cache.html
 org.gradle.caching = true

src/main/kotlin/org/zhavoronkov/openrouter/aiassistant/OpenRouterChatContextProvider.kt

@@ -15,6 +15,7 @@ class OpenRouterChatContextProvider {
     companion object {
         private const val PROVIDER_ID = "openrouter"
         private const val PROVIDER_NAME = "OpenRouter"
+        private const val APPROXIMATE_MODEL_COUNT = 400
     }
 
     /**
@@ -29,15 +30,19 @@ class OpenRouterChatContextProvider {
 
     /**
      * Checks if the provider is available and configured
+     * @param project The project context (currently unused, reserved for future use)
      */
     fun isAvailable(project: Project?): Boolean {
+        // Project parameter reserved for future project-specific configuration
         return settingsService.isConfigured()
     }
 
     /**
      * Provides context information for chat conversations
+     * @param project The project context (currently unused, reserved for future use)
      */
     fun getContextInfo(project: Project?): Map<String, Any> {
+        // Project parameter reserved for future project-specific context
         PluginLogger.Settings.debug("Providing chat context for OpenRouter")
 
         return mapOf(
@@ -52,7 +57,7 @@ class OpenRouterChatContextProvider {
                 "streaming",
                 "multiple_models"
             ),
-            "modelCount" to 400 // OpenRouter supports 400+ models
+            "modelCount" to APPROXIMATE_MODEL_COUNT
         )
     }
 

src/main/kotlin/org/zhavoronkov/openrouter/aiassistant/OpenRouterChatModelProvider.kt

@@ -19,6 +19,13 @@ class OpenRouterChatModelProvider {
         private const val MAX_TOKENS_DEFAULT = 2000
         private const val TEMPERATURE_DEFAULT = 0.7
         private const val SUPPORTS_STREAMING = true
+
+        // Token estimation: ~4 characters per token for most models
+        private const val CHARS_PER_TOKEN = 4
+
+        // HTTP client timeouts (in seconds)
+        private const val CONNECT_TIMEOUT_SECONDS = 30L
+        private const val READ_TIMEOUT_SECONDS = 60L
     }
 
     /**
@@ -83,16 +90,19 @@ class OpenRouterChatModelProvider {
 
     /**
      * Check if streaming is supported for the given model
+     * @param modelId The model ID (currently unused, all models support streaming)
      */
-    fun supportsStreaming(_modelId: String): Boolean = SUPPORTS_STREAMING
+    fun supportsStreaming(modelId: String): Boolean {
+        // All OpenRouter models support streaming, parameter reserved for future model-specific logic
+        return SUPPORTS_STREAMING
+    }
 
     /**
      * Get the estimated token count for a message
      * This is a rough approximation since we don't have access to the exact tokenizer
      */
     fun estimateTokenCount(text: String): Int {
-        // Rough estimation: ~4 characters per token for most models
-        return (text.length / 4).coerceAtLeast(1)
+        return (text.length / CHARS_PER_TOKEN).coerceAtLeast(1)
     }
 
     private fun createChatRequestBody(
@@ -122,8 +132,8 @@ class OpenRouterChatModelProvider {
             )
 
             val client = okhttp3.OkHttpClient.Builder()
-                .connectTimeout(30, java.util.concurrent.TimeUnit.SECONDS)
-                .readTimeout(60, java.util.concurrent.TimeUnit.SECONDS)
+                .connectTimeout(CONNECT_TIMEOUT_SECONDS, java.util.concurrent.TimeUnit.SECONDS)
+                .readTimeout(READ_TIMEOUT_SECONDS, java.util.concurrent.TimeUnit.SECONDS)
                 .build()
 
             client.newCall(request).execute().use { response ->
@@ -142,38 +152,43 @@ class OpenRouterChatModelProvider {
 
     private fun parseOpenRouterResponse(responseBody: String?): ChatResponse {
         return try {
-            if (responseBody.isNullOrBlank()) {
-                return ChatResponse.error("Empty response from OpenRouter")
+            when {
+                responseBody.isNullOrBlank() -> ChatResponse.error("Empty response from OpenRouter")
+                else -> parseValidResponse(responseBody)
             }
+        } catch (e: Exception) {
+            PluginLogger.Service.error("Error parsing OpenRouter response", e)
+            ChatResponse.error("Response parsing failed: ${e.message}")
+        }
+    }
 
-            val responseMap = gson.fromJson(responseBody, Map::class.java) as? Map<String, Any>
-                ?: return ChatResponse.error("Invalid response format")
-
-            // Check for error in response
-            val error = responseMap["error"] as? Map<String, Any>
-            if (error != null) {
-                val errorMessage = error["message"] as? String ?: "Unknown error"
-                return ChatResponse.error(errorMessage)
-            }
+    private fun parseValidResponse(responseBody: String): ChatResponse {
+        val responseMap = gson.fromJson(responseBody, Map::class.java) as? Map<String, Any>
+            ?: return ChatResponse.error("Invalid response format")
+        return parseResponseMap(responseMap)
+    }
 
-            // Parse successful response
-            val choices = responseMap["choices"] as? List<Map<String, Any>>
-            if (choices.isNullOrEmpty()) {
-                return ChatResponse.error("No choices in response")
-            }
+    private fun parseResponseMap(responseMap: Map<String, Any>): ChatResponse {
+        // Check for error in response
+        val error = responseMap["error"] as? Map<String, Any>
+        if (error != null) {
+            val errorMessage = error["message"] as? String ?: "Unknown error"
+            return ChatResponse.error(errorMessage)
+        }
 
+        // Parse successful response
+        val choices = responseMap["choices"] as? List<Map<String, Any>>
+        val content = if (choices != null && choices.isNotEmpty()) {
             val firstChoice = choices[0]
             val message = firstChoice["message"] as? Map<String, Any>
-            val content = message?.get("content") as? String
-
-            if (content != null) {
-                ChatResponse.success(content)
-            } else {
-                ChatResponse.error("No content in response")
-            }
-        } catch (e: Exception) {
-            PluginLogger.Service.error("Error parsing OpenRouter response", e)
-            ChatResponse.error("Response parsing failed: ${e.message}")
+            message?.get("content") as? String
+        } else {
+            null
+        }
+        return if (content != null) {
+            ChatResponse.success(content)
+        } else {
+            ChatResponse.error("No choices or content in response")
         }
     }
 }