twist/build.gradle.kts

import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
import org.gradle.api.plugins.JavaApplication
import org.gradle.api.publish.PublishingExtension
import org.gradle.api.publish.maven.MavenPublication
import org.gradle.authentication.http.BasicAuthentication
import org.gradle.api.credentials.PasswordCredentials

plugins {
    kotlin("jvm") version "2.4.0" apply false
    id("com.ncorti.ktfmt.gradle") version "0.27.0"
}

repositories {
    mavenCentral()
}

val libraryModules = setOf(
    "core", "wire", "transport", "bytecode", "compiler", "proof", "ecdsa", "rsa", "merkle", "store", "state", "access", "gas", "tvm", "jit", "ope",
    "p2p", "gossip", "consensus", "mint", "burn", "bips", "standards", "stake", "router", "did", "miner", "reflect", "twisto", "smartdoc",
)

val twistVersion = providers.gradleProperty("version").orElse("0.1.0-SNAPSHOT")

allprojects {
    group = "rip.crit"
    version = twistVersion.get()
}

val moduleDependencies = mapOf(
    "wire" to listOf("core", "p2p"),
    "transport" to listOf("wire", "p2p", "core"),
    "bytecode" to listOf("core"),
    "compiler" to listOf("bytecode", "jit", "tvm"),
    "proof" to listOf("core", "merkle"),
    "ecdsa" to listOf("core"),
    "rsa" to listOf("core"),
    "merkle" to listOf("core"),
    "store" to listOf("core"),
    "state" to listOf("core"),
    "access" to listOf("core"),
    "tvm" to listOf("core", "gas", "state", "bytecode"),
    "ope" to listOf("core", "tvm", "access"),
    "p2p" to listOf("core"),
    "gossip" to listOf("p2p"),
    "consensus" to listOf("core"),
    "mint" to listOf("core"),
    "burn" to listOf("core"),
    "bips" to listOf("core", "proof"),
    "standards" to listOf("core", "store"),
    "stake" to listOf("core", "store"),
    "router" to listOf("core", "proof", "ecdsa", "p2p", "store"),
    "did" to listOf("core", "p2p", "store"),
    "miner" to listOf("core", "proof"),
    "reflect" to listOf("core", "p2p", "store", "wire"),
    "twisto" to listOf("core", "standards", "bips", "store", "compiler"),
    "smartdoc" to listOf("core"),
)

ktfmt {
    kotlinLangStyle() 
}

tasks.register<com.ncorti.ktfmt.gradle.tasks.KtfmtCheckTask>("fmtCheck") {
    group = "verification"
    source = project.fileTree(layout.projectDirectory.dir("app/src/main/kotlin")) {
        include("**/*.kt")
    }
}

tasks.register<com.ncorti.ktfmt.gradle.tasks.KtfmtFormatTask>("fmt") {
    group = "formatting"
    source = project.fileTree(layout.projectDirectory.dir("app/src/main/kotlin")) {
        include("**/*.kt")
    }
}

subprojects {
    apply(plugin = "org.jetbrains.kotlin.jvm")

    layout.buildDirectory.set(rootProject.layout.buildDirectory.dir("projects/${project.name}"))

    repositories { mavenCentral() }

    extensions.configure<KotlinJvmProjectExtension> {
        jvmToolchain(25)
        sourceSets.named("main") {
            kotlin.srcDir(rootProject.file("app/src/main/kotlin"))
            kotlin.include("rip/crit/twist/${project.name}/**")
        }
    }

    tasks.withType<KotlinCompile>().configureEach {
        compilerOptions.freeCompilerArgs.add("-Xjsr305=strict")
    }
}

configure(subprojects.filter { it.name in libraryModules }) {
    apply(plugin = "java-library")
    apply(plugin = "maven-publish")

    extensions.configure<org.gradle.api.plugins.JavaPluginExtension> {
        withSourcesJar()
        withJavadocJar()
    }

    dependencies {
        moduleDependencies[name].orEmpty().forEach { dependency -> add("api", project(":$dependency")) }
    }

    extensions.configure<PublishingExtension> {
        publications {
            create<MavenPublication>("mavenJava") {
                from(components["java"])
                artifactId = "twist-${project.name}"
                pom {
                    name.set("Twist ${project.name}")
                    description.set(project.description ?: "Twist ${project.name} library")
                }
            }
        }
        repositories {
            maven {
                name = "forgejo"
                url = uri("https://ai.crit.rip/api/packages/jprims/maven")
                credentials(PasswordCredentials::class) {
                    username = providers.gradleProperty("forgejoUsername").orNull
                    password = providers.gradleProperty("forgejoPassword").orNull
                }
                authentication {
                    create<BasicAuthentication>("basic")
                }
            }
        }
    }
}

project(":app") {
    apply(plugin = "application")
    extensions.configure<KotlinJvmProjectExtension> {
        sourceSets.named("main") { kotlin.include("rip/crit/twist/App.kt") }
    }
    dependencies {
        libraryModules.forEach { dependency -> add("implementation", project(":$dependency")) }
    }
    extensions.configure<JavaApplication> {
        mainClass.set("rip.crit.twist.AppKt")
    }
}

project(":compiler-app") {
    apply(plugin = "application")
    extensions.configure<KotlinJvmProjectExtension> {
        sourceSets.named("main") {
            kotlin.setSrcDirs(listOf(rootProject.file("apps/compiler/src/main/kotlin")))
            kotlin.setIncludes(emptySet())
        }
    }
    dependencies { add("implementation", project(":compiler")) }
    extensions.configure<JavaApplication> { mainClass.set("rip.crit.twist.tool.compiler.MainKt") }
}

fun configureTool(projectName: String, sourceDirectory: String, dependency: String, entryPoint: String) {
    project(projectName) {
        apply(plugin = "application")
        extensions.configure<KotlinJvmProjectExtension> {
            sourceSets.named("main") {
                kotlin.setSrcDirs(listOf(rootProject.file(sourceDirectory)))
                kotlin.setIncludes(emptySet())
            }
        }
        dependencies { add("implementation", project(dependency)) }
        extensions.configure<JavaApplication> { mainClass.set(entryPoint) }
    }
}

configureTool(":miner-tool", "apps/miner/src/main/kotlin", ":miner", "rip.crit.twist.tool.miner.MainKt")
project(":miner-tool") {
    dependencies {
        add("implementation", project(":stake"))
        add("implementation", project(":store"))
    }
}
configureTool(":reflect-tool", "apps/reflect/src/main/kotlin", ":reflect", "rip.crit.twist.tool.reflect.MainKt")
configureTool(":twisto-tool", "apps/twisto/src/main/kotlin", ":twisto", "rip.crit.twist.tool.twisto.MainKt")
configureTool(":docs-tool", "apps/docs/src/main/kotlin", ":smartdoc", "rip.crit.twist.tool.docs.MainKt")