Port PromptTemplate

build.gradle.kts

@@ -8,10 +8,10 @@ repositories {
 }
 
 plugins {
-    base
-    alias(libs.plugins.kotlin.multiplatform)
-    alias(libs.plugins.spotless)
-    alias(libs.plugins.kotlinx.serialization)
+  base
+  alias(libs.plugins.kotlin.multiplatform)
+  alias(libs.plugins.spotless)
+  alias(libs.plugins.kotlinx.serialization)
 }
 
 java {
@@ -41,31 +41,33 @@ kotlin {
   val hostOs = System.getProperty("os.name")
   val isMingwX64 = hostOs.startsWith("Windows")
   when {
-        hostOs == "Mac OS X" -> macosX64("native")
-        hostOs == "Linux" -> linuxX64("native")
-        isMingwX64 -> mingwX64("native")
-        else -> throw GradleException("Host OS is not supported in Kotlin/Native.")
-    }
+    hostOs == "Mac OS X" -> macosX64("native")
+    hostOs == "Linux" -> linuxX64("native")
+    isMingwX64 -> mingwX64("native")
+    else -> throw GradleException("Host OS is not supported in Kotlin/Native.")
+  }
+
 
-
     sourceSets {
         commonMain {
             dependencies {
                 implementation(libs.arrow.fx)
                 implementation(libs.kotlinx.serialization.json)
                 implementation(libs.bundles.ktor.client)
-            }
-        }
-        commonTest {
-            dependencies {
-                implementation(kotlin("test"))
-            }
-        }
+
+        implementation("com.squareup.okio:okio:3.3.0")
+      }
+    }
+    commonTest {
+      dependencies {
+        implementation(kotlin("test"))
+      }
     }
+  }
 }
 
 spotless {
-    kotlin {
-        ktfmt().googleStyle()
-    }
+  kotlin {
+    ktfmt().googleStyle()
+  }
 }

src/commonMain/kotlin/com/xebia/functional/prompt/PromptTemplate.kt

@@ -0,0 +1,66 @@
+package com.xebia.functional.prompt
+
+import okio.FileSystem
+import okio.Path
+import okio.buffer
+import okio.use
+
+interface PromptTemplate {
+  val inputKeys: List<String>
+  suspend fun format(variables: Map<String, String>): String
+
+  companion object {
+    operator fun invoke(config: Config): PromptTemplate = object : PromptTemplate {
+      override val inputKeys: List<String> = config.inputVariables
+
+      override suspend fun format(variables: Map<String, String>): String {
+        val mergedArgs = mergePartialAndUserVariables(variables, config.inputVariables)
+        return when (config.templateFormat) {
+          TemplateFormat.Jinja2 -> TODO()
+          TemplateFormat.FString -> {
+            val sortedArgs = mergedArgs.toList().sortedBy { it.first }
+            sortedArgs.fold(config.template) { acc, (k, v) -> acc.replace("{$k}", v) }
+          }
+        }
+      }
+
+      private fun mergePartialAndUserVariables(
+        variables: Map<String, String>,
+        inputVariables: List<String>
+      ): Map<String, String> =
+        inputVariables.fold(variables) { acc, k ->
+          if (!acc.containsKey(k)) acc + (k to "{$k}") else acc
+        }
+    }
+
+    suspend fun fromExamples(
+      examples: List<String>,
+      suffix: String,
+      inputVariables: List<String>,
+      prefix: String
+    ): PromptTemplate {
+      val template = """|$prefix
+      |
+      |${examples.joinToString(separator = "\n")}
+      |$suffix""".trimMargin()
+      return PromptTemplate(Config.orThrow(template, inputVariables))
+    }
+
+    suspend fun fromTemplate(template: String, inputVariables: List<String>): PromptTemplate =
+      PromptTemplate(Config.orThrow(template, inputVariables))
+
+    // TODO IO Dispatcher KMP ??
+    suspend fun fromFile(
+      templateFile: Path,
+      inputVariables: List<String>,
+      fileSystem: FileSystem
+    ): PromptTemplate =
+      fileSystem.source(templateFile).use { source ->
+        source.buffer().use { buffer ->
+          val template = buffer.readUtf8()
+          val config = Config.orThrow(template, inputVariables)
+          PromptTemplate(config)
+        }
+      }
+  }
+}

src/commonMain/kotlin/com/xebia/functional/prompt/models.kt

@@ -0,0 +1,54 @@
+package com.xebia.functional.prompt
+
+import arrow.core.EitherNel
+import arrow.core.getOrElse
+import arrow.core.raise.Raise
+import arrow.core.raise.either
+import arrow.core.raise.ensure
+import arrow.core.raise.zipOrAccumulate
+
+enum class TemplateFormat(name: String) {
+  Jinja2("jinja2"),
+  FString("f-string")
+}
+
+data class InvalidTemplate(val reason: String)
+
+data class Config private constructor(
+  val inputVariables: List<String>,
+  val template: String,
+  val templateFormat: TemplateFormat = TemplateFormat.FString
+) {
+  companion object {
+    operator fun invoke(template: String, inputVariables: List<String>): EitherNel<InvalidTemplate, Config> =
+      either {
+        val placeholders = placeholderValues(template)
+
+        zipOrAccumulate(
+          { validate(template, inputVariables.toSet() - placeholders.toSet(), "unused") },
+          { validate(template, placeholders.toSet() - inputVariables.toSet(), "missing") },
+          { validateDuplicated(template, placeholders) }
+        ) { _, _, _ -> Config(inputVariables, template) }
+      }
+
+    fun orThrow(template: String, inputVariables: List<String>): Config =
+      invoke(template, inputVariables).getOrElse { throw IllegalArgumentException(it.all.joinToString(transform = InvalidTemplate::reason)) }
+  }
+}
+
+private fun Raise<InvalidTemplate>.validate(template: String, diffSet: Set<String>, msg: String): Unit =
+  ensure(diffSet.isEmpty()) {
+    InvalidTemplate("Template '$template' has $msg arguments: ${diffSet.joinToString(", ")}")
+  }
+
+private fun Raise<InvalidTemplate>.validateDuplicated(template: String, placeholders: List<String>) {
+  val args = placeholders.groupBy { it }.filter { it.value.size > 1 }.keys
+  ensure(args.isEmpty()) {
+    InvalidTemplate("Template '$template' has duplicate arguments: ${args.joinToString(", ")}")
+  }
+}
+
+private fun placeholderValues(template: String): List<String> {
+  val regex = Regex("""\{([^\{\}]+)\}""")
+  return regex.findAll(template).toList().mapNotNull { it.groupValues.firstOrNull() }
+}