refactor: Code Formatting with Spotless and update to latest version

Author: hanrw

.github/workflows/releaase-to-central-sonatype.yml

@@ -1,29 +1,82 @@
-name: build and publish a release to Central Sonatype
+name: Release to Central Sonatype
 
-#on:
-#  release:
-#    types: [published]
+# Release workflow for publishing OpenAI Kotlin SDK to Maven Central via Sonatype Portal
+#
+# Triggers:
+# - Manual trigger with version input (e.g., 1.0.0, 1.1.0-beta.1)
+# - Automatically creates git tag and GitHub release
+# - Publishes to Maven Central via Central Sonatype Portal
+#
+# Process:
+# 1. Validate version format (semantic versioning)
+# 2. Build and test with specified version
+# 3. Create git tag and GitHub release
+# 4. Publish to Maven Central via Sonatype Portal
 
 on:
   workflow_dispatch:
+    inputs:
+      version:
+        description: 'Release version (e.g., 1.0.0, 1.1.0-beta.1)'
+        required: true
+        type: string
 
 jobs:
-  build:
+  # Build, test and publish the SDK to Maven Central
+  release:
     runs-on: macOS-latest
-    env:
-      SONATYPE_USERNAME: ${{ secrets.SONATYPE_USERNAME }}
-      SONATYPE_PASSWORD: ${{ secrets.SONATYPE_PASSWORD }}
-      SIGNING_KEY: ${{ secrets.SIGNING_KEY }}
-      SIGNING_PASSWORD: ${{ secrets.SIGNING_PASSWORD }}
+    permissions:
+      contents: write
+      actions: read
     steps:
       - name: Checkout sources
         uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          
       - name: Setup Java
         uses: actions/setup-java@v4
         with:
-          distribution: zulu
+          distribution: 'temurin'
           java-version: 17
+          
       - name: Setup Gradle
-        uses: gradle/gradle-build-action@v3
-      - name: Release to Central Sonatype with Gradle
-        run: ./gradlew build publishAggregationPublicationsToSonatypePortalRepository
+        uses: gradle/actions/setup-gradle@v4
+        
+      - name: Validate version format
+        run: |
+          if [[ ! "${{ inputs.version }}" =~ ^[0-9]+\.[0-9]+\.[0-9]+(-[a-zA-Z0-9.-]+)?$ ]]; then
+            echo "❌ Invalid version format. Use semantic versioning (e.g., 1.0.0, 1.1.0-beta.1)"
+            exit 1
+          fi
+          echo "✅ Version format is valid: ${{ inputs.version }}"
+          
+      - name: Build and test with release version
+        run: ./gradlew clean build koverVerify -PLIBRARY_VERSION=${{ inputs.version }}
+        
+      - name: Code quality checks
+        run: ./gradlew spotlessCheck buildHealth -PLIBRARY_VERSION=${{ inputs.version }}
+        
+      - name: Create git tag
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git tag -a "v${{ inputs.version }}" -m "Release v${{ inputs.version }}"
+          git push origin "v${{ inputs.version }}"
+          
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v1
+        with:
+          tag_name: v${{ inputs.version }}
+          name: v${{ inputs.version }}
+          draft: false
+          prerelease: ${{ contains(inputs.version, '-') }}
+          generate_release_notes: true
+          
+      - name: Publish to Maven Central via Sonatype Portal
+        run: ./gradlew publishToCentral -PLIBRARY_VERSION=${{ inputs.version }}
+        env:
+          SONATYPE_USERNAME: ${{ secrets.SONATYPE_USERNAME }}
+          SONATYPE_PASSWORD: ${{ secrets.SONATYPE_PASSWORD }}
+          SIGNING_KEY: ${{ secrets.SIGNING_KEY }}
+          SIGNING_PASSWORD: ${{ secrets.SIGNING_PASSWORD }}

anthropic-client/anthropic-client-core/build.gradle.kts

@@ -21,13 +21,9 @@ kotlin {
             api(projects.common)
         }
 
-        macosMain.dependencies {
-            api(libs.ktor.client.darwin)
-        }
+        macosMain.dependencies { api(libs.ktor.client.darwin) }
 
-        jvmMain.dependencies {
-            api(libs.ktor.client.cio)
-        }
+        jvmMain.dependencies { api(libs.ktor.client.cio) }
 
         jvmTest.dependencies {
             implementation(project.dependencies.platform(libs.junit.bom))
@@ -44,8 +40,4 @@ kotlin {
     }
 }
 
-tasks {
-    named<Test>("jvmTest") {
-        useJUnitPlatform()
-    }
-}
+tasks { named<Test>("jvmTest") { useJUnitPlatform() } }

anthropic-client/anthropic-client-core/src/commonMain/kotlin/com/tddworks/anthropic/api/Anthropic.kt

@@ -7,36 +7,32 @@ import com.tddworks.anthropic.api.messages.api.internal.JsonLenient
 import com.tddworks.common.network.api.ktor.api.HttpRequester
 import com.tddworks.common.network.api.ktor.internal.*
 
-/**
- * Interface for interacting with the Anthropic API.
- */
+/** Interface for interacting with the Anthropic API. */
 interface Anthropic : Messages {
 
-    /**
-     * Companion object containing a constant variable for the base URL of the API.
-     */
+    /** Companion object containing a constant variable for the base URL of the API. */
     companion object {
         const val BASE_URL = "https://api.anthropic.com"
         const val ANTHROPIC_VERSION = "2023-06-01"
 
         /**
          * Creates an instance of Anthropic API with the provided configurations.
+         *
          * @return an instance of Anthropic API configured with the provided settings.
          */
         fun create(anthropicConfig: AnthropicConfig): Anthropic {
 
-            val requester = HttpRequester.default(
-                createHttpClient(
-                    connectionConfig = UrlBasedConnectionConfig(anthropicConfig.baseUrl),
-                    authConfig = AuthConfig(anthropicConfig.apiKey),
-                    // get from commonModule
-                    features = ClientFeatures(json = JsonLenient)
+            val requester =
+                HttpRequester.default(
+                    createHttpClient(
+                        connectionConfig = UrlBasedConnectionConfig(anthropicConfig.baseUrl),
+                        authConfig = AuthConfig(anthropicConfig.apiKey),
+                        // get from commonModule
+                        features = ClientFeatures(json = JsonLenient),
+                    )
                 )
-            )
-            val messages = DefaultMessagesApi(
-                anthropicConfig = anthropicConfig,
-                requester = requester
-            )
+            val messages =
+                DefaultMessagesApi(anthropicConfig = anthropicConfig, requester = requester)
 
             return AnthropicApi(anthropicConfig = anthropicConfig, messages = messages)
         }
@@ -57,11 +53,10 @@ interface Anthropic : Messages {
     fun baseUrl(): String
 
     /**
-     * Returns the anthropic version of the provided class.
-     * The anthropic version is a String representation of the class name with "Anthropic"
-     * prefixed to it.
+     * Returns the anthropic version of the provided class. The anthropic version is a String
+     * representation of the class name with "Anthropic" prefixed to it.
      *
      * @return The anthropic version of the class as a String.
      */
     fun anthropicVersion(): String
-}
+}

anthropic-client/anthropic-client-core/src/commonMain/kotlin/com/tddworks/anthropic/api/AnthropicConfig.kt

@@ -3,14 +3,15 @@ package com.tddworks.anthropic.api
 import org.koin.core.component.KoinComponent
 
 /**
- * @param apiKey a function that returns the API key to be used for authentication. Defaults to "CONFIGURE_ME" if not provided.
- * @param baseUrl a function that returns the base URL of the API. Defaults to the value specified in the Anthropic companion object if not provided.
- * @param anthropicVersion a function that returns the version of the Anthropic API to be used. Defaults to "2023-06-01" if not provided.
+ * @param apiKey a function that returns the API key to be used for authentication. Defaults to
+ *   "CONFIGURE_ME" if not provided.
+ * @param baseUrl a function that returns the base URL of the API. Defaults to the value specified
+ *   in the Anthropic companion object if not provided.
+ * @param anthropicVersion a function that returns the version of the Anthropic API to be used.
+ *   Defaults to "2023-06-01" if not provided.
  */
 data class AnthropicConfig(
     val apiKey: () -> String = { "CONFIG_API_KEY" },
     val baseUrl: () -> String = { Anthropic.BASE_URL },
     val anthropicVersion: () -> String = { Anthropic.ANTHROPIC_VERSION },
 ) : KoinComponent
-
-

anthropic-client/anthropic-client-core/src/commonMain/kotlin/com/tddworks/anthropic/api/AnthropicModel.kt

@@ -1,47 +1,47 @@
 package com.tddworks.anthropic.api
 
-import kotlinx.serialization.Serializable
 import kotlin.jvm.JvmInline
+import kotlinx.serialization.Serializable
 
 /**
  * https://docs.anthropic.com/claude/docs/models-overview
- * https://docs.anthropic.com/en/docs/about-claude/models
- * Claude is a family of state-of-the-art large language models developed by Anthropic. Our models are designed to provide you with the best possible experience when interacting with AI, offering a range of capabilities and performance levels to suit your needs and make it easy to deploy high performing, safe, and steerable models. In this guide, we'll introduce you to our latest and greatest models, the Claude 3 family, as well as our legacy models, which are still available for those who need them.
+ * https://docs.anthropic.com/en/docs/about-claude/models Claude is a family of state-of-the-art
+ * large language models developed by Anthropic. Our models are designed to provide you with the
+ * best possible experience when interacting with AI, offering a range of capabilities and
+ * performance levels to suit your needs and make it easy to deploy high performing, safe, and
+ * steerable models. In this guide, we'll introduce you to our latest and greatest models, the
+ * Claude 3 family, as well as our legacy models, which are still available for those who need them.
  */
 @Serializable
 @JvmInline
 value class AnthropicModel(val value: String) {
     companion object {
         /**
-         * Most powerful model for highly complex tasks
-         * Max output length: 4096 tokens
-         * Cost (Input / Output per MTok^) $15.00 / $75.00
+         * Most powerful model for highly complex tasks Max output length: 4096 tokens Cost (Input /
+         * Output per MTok^) $15.00 / $75.00
          */
         val CLAUDE_3_OPUS = AnthropicModel("claude-3-opus-20240229")
 
         /**
-         * Ideal balance of intelligence and speed for enterprise workloads
-         * Max output length: 4096 tokens
-         * Cost (Input / Output per MTok^) $3.00 / $15.00
+         * Ideal balance of intelligence and speed for enterprise workloads Max output length: 4096
+         * tokens Cost (Input / Output per MTok^) $3.00 / $15.00
          */
         val CLAUDE_3_Sonnet = AnthropicModel("claude-3-sonnet-20240229")
 
         /**
-         * Most intelligent model
-         * The model costs $3 per million input tokens and $15 per million output tokens, with a 200K token context window.
-         * Cost (Input / Output per MTok^) $3.00 / $15.00
-         * Training data cut-off: Apr 2024
+         * Most intelligent model The model costs $3 per million input tokens and $15 per million
+         * output tokens, with a 200K token context window. Cost (Input / Output per MTok^) $3.00 /
+         * $15.00 Training data cut-off: Apr 2024
          */
         val CLAUDE_3_5_Sonnet = AnthropicModel("claude-3-5-sonnet-20240620")
 
         /**
-         * Fastest and most compact model for near-instant responsiveness
-         * Max output length: 4096 tokens
-         * Cost (Input / Output per MTok^) $0.25 / $1.25
+         * Fastest and most compact model for near-instant responsiveness Max output length: 4096
+         * tokens Cost (Input / Output per MTok^) $0.25 / $1.25
          */
         val CLAUDE_3_HAIKU = AnthropicModel("claude-3-haiku-20240307")
 
         val availableModels =
             listOf(CLAUDE_3_OPUS, CLAUDE_3_Sonnet, CLAUDE_3_HAIKU, CLAUDE_3_5_Sonnet)
     }
-}
+}

anthropic-client/anthropic-client-core/src/commonMain/kotlin/com/tddworks/anthropic/api/internal/AnthropicApi.kt

@@ -5,17 +5,17 @@ import com.tddworks.anthropic.api.AnthropicConfig
 import com.tddworks.anthropic.api.messages.api.Messages
 import com.tddworks.di.getInstance
 
-
 /**
- * The Anthropic API class encapsulates the necessary properties and methods to interact with the Anthropic API.
+ * The Anthropic API class encapsulates the necessary properties and methods to interact with the
+ * Anthropic API.
  *
  * @property apiKey the unique identifier for your Anthropic API account
  * @property apiURL the base URL for making API requests to the Anthropic API
  * @property anthropicVersion the version of the Anthropics library being used
  */
 class AnthropicApi(
     private val anthropicConfig: AnthropicConfig,
-    private val messages: Messages = getInstance()
+    private val messages: Messages = getInstance(),
 ) : Anthropic, Messages by messages {
     /**
      * Gets the API key.
@@ -43,13 +43,11 @@ class AnthropicApi(
     override fun anthropicVersion(): String {
         return anthropicConfig.anthropicVersion()
     }
-
 }
 
 fun Anthropic.Companion.create(
-    anthropicConfig: AnthropicConfig, messages: Messages = getInstance()
+    anthropicConfig: AnthropicConfig,
+    messages: Messages = getInstance(),
 ): Anthropic {
-    return AnthropicApi(
-        anthropicConfig = anthropicConfig, messages = messages
-    )
-}
+    return AnthropicApi(anthropicConfig = anthropicConfig, messages = messages)
+}

anthropic-client/anthropic-client-core/src/commonMain/kotlin/com/tddworks/anthropic/api/messages/api/ContentMessage.kt

@@ -2,5 +2,4 @@ package com.tddworks.anthropic.api.messages.api
 
 import kotlinx.serialization.Serializable
 
-@Serializable
-data class ContentMessage(val text: String, val type: String)
+@Serializable data class ContentMessage(val text: String, val type: String)