Push works

buildSrc/src/main/kotlin/school/ai/AssistantManager.kt

@@ -74,17 +74,11 @@ object AssistantManager {
     ): Either<Throwable, Response<AiMessage>> = catch {
         suspendCancellableCoroutine { continuation ->
             model.generate(promptMessage, object : StreamingResponseHandler<AiMessage> {
-                override fun onNext(token: String) {
-                    print(token)
-                }
+                override fun onNext(token: String) = print(token)
 
-                override fun onComplete(response: Response<AiMessage>) {
-                    continuation.resume(response)
-                }
+                override fun onComplete(response: Response<AiMessage>) = continuation.resume(response)
 
-                override fun onError(error: Throwable) {
-                    continuation.resume(Left(error).getOrElse { throw it })
-                }
+                override fun onError(error: Throwable) = continuation.resume(Left(error).getOrElse { throw it })
             })
         }
     }

buildSrc/src/main/kotlin/school/translate/TranslatorManager.kt

@@ -1,37 +1,47 @@
+@file:Suppress("MemberVisibilityCanBePrivate")
+
 package school.translate
 
+import arrow.core.Either.Left
+import arrow.core.Either.Right
+import kotlinx.coroutines.runBlocking
+import org.gradle.api.Project
+import school.ai.AssistantManager.createOllamaChatModel
+import school.ai.AssistantManager.createOllamaStreamingChatModel
+import school.ai.AssistantManager.generateStreamingResponse
 import school.translate.TranslatorManager.PromptManager.translateMessage
 import school.translate.TranslatorManager.PromptManager.userLanguage
+import school.translate.TranslatorManager.translatorSupportedLanguages
 import school.workspace.WorkspaceUtils.uppercaseFirstChar
 import java.util.*
 
 object TranslatorManager {
     @JvmStatic
-    fun main(args: Array<String>) = translatorSupportedLanguages
-        .translationTasks()
-        .forEach(::println)
-        .run {
-            userLanguage.run { "userLanguage : $this" }.run(::println)
-            translateMessage.run { "translateMessage : $this" }.run(::println)
-        }.run {
-
-            val currentLocale = Locale.getDefault()
-            currentLocale.run { "currentLocale : $this" }.run(::println)
-            // Force English language for display
-            Locale.setDefault(Locale.ENGLISH)
-
+    fun main(args: Array<String>) {
+        translatorSupportedLanguages
+            .translationTasks()
+            .forEach(::println)
+            .run {
+                userLanguage.run { "userLanguage : $this" }.run(::println)
+                translateMessage.run { "translateMessage : $this" }.run(::println)
+            }.run {
+                val currentLocale = Locale.getDefault()
+                currentLocale.run { "currentLocale : $this" }.run(::println)
+                // Force English language for display
+                Locale.setDefault(Locale.ENGLISH)
+                // Get the display name of the English locale
+                val englishDisplayName = Locale.ENGLISH.getDisplayLanguage(Locale.ENGLISH)
+                println("English display name: $englishDisplayName")
+            }
+    }
 
-            // Get the display name of the English locale
-            val englishDisplayName = Locale.ENGLISH.getDisplayLanguage(Locale.ENGLISH)
-            println("English display name: $englishDisplayName")
-        }
 
     @JvmStatic
     val translatorSupportedLanguages: Set<String> = setOf(
         Locale.FRENCH,
         Locale.ENGLISH,
         Locale.GERMAN,
-        Locale.of("es")
+        Locale.forLanguageTag("es")
     ).map { it.language }.toSet()
 
     @JvmStatic
@@ -53,4 +63,62 @@ object TranslatorManager {
         val translateMessage = """Translate this sentence from $userLanguage to english : 
             | """.trimMargin()
     }
+
+
+    //translatorSupportedLanguages
+    // Creating tasks for each model
+    fun Project.createTranslationTasks() = translatorSupportedLanguages
+        .translationTasks()
+        .forEach {
+            val model = "aya:8b"
+            createTranslationChatTask(model, "translate${it}")
+            createStreamingTranslationChatTask(model, "translateStream${it}")
+        }
+
+    // Generic function for chat model tasks
+    fun Project.createTranslationChatTask(model: String, taskName: String) {
+        task(taskName) {
+            group = "translator"
+            description = "Translate using the Ollama $model chatgpt prompt request."
+            doFirst {
+                //TODO : add content mechanism to capture text, from gradle tasks input
+                val text = ""
+                project.runTranslationChat(model, translateMessage.run { "$this : \n$text" })
+            }
+        }
+    }
+
+    // Generic function for streaming chat model tasks
+    fun Project.createStreamingTranslationChatTask(model: String, taskName: String) {
+        task(taskName) {
+            group = "translator"
+            description = "Translate the Ollama $model chatgpt stream prompt request."
+            doFirst {
+                val text = ""
+                runStreamTranslationChat(model, translateMessage.run {
+                    //TODO : add content to the prompt, from gradle tasks input
+                    "$this : \n$text"
+                })
+            }
+        }
+    }
+
+    fun Project.runTranslationChat(model: String, text: String) = createOllamaChatModel(model = model)
+        .run { generate(text).let(::println) }
+
+    fun Project.runStreamTranslationChat(model: String, text: String) = runBlocking {
+        createOllamaStreamingChatModel(model).run {
+            when (val answer = generateStreamingResponse(this, translateMessage.run {
+                //TODO : add content to the prompt, from gradle tasks input
+                "$this : \n$text"
+            })) {
+                is Right -> "Complete response received:\n${
+                    answer.value.content().text()
+                }".run(::println)
+
+                is Left -> "Error during response generation:\n${answer.value}".run(::println)
+            }
+        }
+    }
+
 }

buildSrc/src/main/kotlin/school/translate/TranslatorPlugin.kt

@@ -1,10 +1,11 @@
-@file:Suppress("unused")
+@file:Suppress("unused", "MemberVisibilityCanBePrivate")
 
 package school.translate
 
 import org.gradle.api.Plugin
 import org.gradle.api.Project
+import school.translate.TranslatorManager.createTranslationTasks
 
 class TranslatorPlugin : Plugin<Project> {
-    override fun apply(project: Project) {}
+    override fun apply(project: Project) = project.createTranslationTasks()
 }

buildSrc/src/main/kotlin/school/workspace/WorkspaceUtils.kt

@@ -10,24 +10,18 @@ import java.io.ByteArrayOutputStream
 import java.io.File
 import java.nio.file.FileSystems
 
+val project = """
+Creator of Commun Content for Pedagogy dot Education https://cccp.education/
+"""
+
 object WorkspaceUtils {
     @JvmStatic
-    val String.uppercaseFirstChar
-        get() = run {
-            replaceFirst(
-                first(),
-                first().uppercaseChar()
-            )
-        }
+    val String.uppercaseFirstChar: String
+        get() = replaceFirst(first(), first().uppercaseChar())
 
     @JvmStatic
-    val String.lowercaseFirstChar
-        get() = run {
-            replaceFirst(
-                first(),
-                first().lowercaseChar()
-            )
-        }
+    val String.lowercaseFirstChar: String
+        get() = replaceFirst(first(), first().lowercaseChar())
 
     fun Project.purchaseArtifact() = ("artifact.group" to "artifact.version").run {
         group = properties[first].toString()