build.gradle

import com.github.spotbugs.snom.Effort
import com.github.spotbugs.snom.Confidence

plugins {
    id 'application'
    id 'jacoco'
    id 'pmd'
    id 'com.github.spotbugs' version '6.5.8'
    id 'net.ltgt.errorprone' version '5.1.0'
}

group = 'se.deversity'
version = '0.1.0'

ext.vibetagsVersion = '1.3.2'
// code-karta renders the diagrams under docs/diagrams straight from this source tree.
ext.codekartaVersion = '0.2.0'

repositories {
    mavenCentral()
}

configurations {
    // Tool-only: the diagram renderer must never reach a compile or runtime classpath.
    codekarta
}

dependencies {
    implementation 'info.picocli:picocli:4.7.7'
    implementation 'org.jsoup:jsoup:1.22.2'
    implementation 'com.fasterxml.jackson.core:jackson-databind:2.22.0'

    // Native Anthropic SDK for the optional hosted Claude synthesis provider. Local-first
    // stays the default; this is only used with --llm-provider anthropic.
    implementation 'com.anthropic:anthropic-java:2.43.0'

    // JSpecify nullness annotations (@NullMarked on package-info, @Nullable on APIs).
    // CLASS-retention, so compile-only is enough — nothing is needed at runtime.
    compileOnly 'org.jspecify:jspecify:1.0.0'

    // VibeTags: compile-time AI guardrail annotations + processor. SOURCE-retention,
    // zero runtime footprint; the processor regenerates the AI config files on compile.
    compileOnly "se.deversity.vibetags:vibetags-processor:${vibetagsVersion}"
    annotationProcessor "se.deversity.vibetags:vibetags-processor:${vibetagsVersion}"

    // Error Prone — bug-pattern checks woven into javac (main sources only).
    errorprone 'com.google.errorprone:error_prone_core:2.50.0'

    // JUnit Jupiter 6.0.3+ is required by async-test-lib; archunit-junit5 1.4.x is compatible.
    testImplementation 'org.junit.jupiter:junit-jupiter:6.1.0'
    testImplementation 'org.mockito:mockito-core:5.23.0'
    testImplementation 'org.mockito:mockito-junit-jupiter:5.23.0'
    testImplementation 'com.tngtech.archunit:archunit-junit5:1.4.2'
    // async-test-lib: JUnit 5 extension that stress-tests concurrent code (@AsyncTest).
    testImplementation 'se.deversity.async-test-lib:async-test-lib:1.12.0'
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher:6.1.0'

    // code-karta CLI (shaded), used only by the `diagrams` task below.
    codekarta "se.deversity.codekarta:code-karta-cli:${codekartaVersion}:all"
}

application {
    mainClass = 'se.deversity.skill3.Skill3App'
}

// Build, test and run on JDK 25. The toolchain is provisioned by Gradle (auto-detected
// from installed JDKs, or downloaded via the Foojay resolver in settings.gradle), so the
// build no longer depends on JAVA_HOME — it works regardless of the JDK running Gradle.
java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(25)
    }
}

// Target Java 25 bytecode. Redundant with the toolchain above, but kept explicit so the
// bytecode floor is obvious and survives any future toolchain change.
tasks.withType(JavaCompile).configureEach {
    options.release = 25
    options.encoding = 'UTF-8'
    // Point VibeTags at the project root (Gradle runs javac in a worker whose CWD differs)
    // and set the project name used in generated llms.txt / llms-full.txt headers.
    options.compilerArgs += ["-Avibetags.root=${rootDir}".toString(), '-Avibetags.project=Skill3']
}

// Error Prone: enabled on main sources, disabled on tests (mocks/fixtures trip checks
// that don't apply to production code).
tasks.named('compileJava') {
    options.errorprone {
        // SOURCE-retention guardrail annotations have no canonical javac home; silence
        // the unrelated finalize() check that doesn't apply to this codebase.
        disable('UnsafeFinalization')
    }
}
tasks.named('compileTestJava') {
    options.errorprone.enabled = false
}

tasks.named('test') {
    useJUnitPlatform()
    // async-test-lib (@AsyncTest) is PolyForm Noncommercial; run its license guard in mock
    // mode for the test JVM (noncommercial development use).
    jvmArgs '-Dlicense.mock.mode=true'
    testLogging {
        events 'passed', 'skipped', 'failed'
    }
    finalizedBy jacocoTestReport
}

jacocoTestReport {
    dependsOn test
    reports {
        xml.required = true
        html.required = true
    }
}

// Coverage gate, set below current (~81% instruction / ~72% branch) to catch regressions
// without being brittle. Wired into `check`, so CI fails if coverage drops materially.
jacocoTestCoverageVerification {
    dependsOn test
    violationRules {
        rule {
            limit {
                counter = 'INSTRUCTION'
                minimum = 0.75
            }
            limit {
                counter = 'BRANCH'
                minimum = 0.65
            }
        }
    }
}
tasks.named('check') {
    dependsOn jacocoTestCoverageVerification
}

pmd {
    consoleOutput = true
    toolVersion = '7.25.0'
    ignoreFailures = false
    ruleSets = []  // use only our curated ruleset, not PMD's defaults
    ruleSetFiles = files("$rootDir/config/pmd-ruleset.xml")
}
tasks.named('pmdTest') { enabled = false }

spotbugs {
    toolVersion = '4.10.2'  // pin a SpotBugs that understands Java 25 class files
    effort = Effort.valueOf('MAX')
    reportLevel = Confidence.valueOf('LOW')
    ignoreFailures = false
    excludeFilter = file("$rootDir/config/spotbugs-exclude.xml")
}
tasks.named('spotbugsTest') { enabled = false }
tasks.named('spotbugsMain') {
    reports {
        html { required = true }
        xml { required = true }
    }
}

// ---- Generated architecture diagrams (code-karta) ---------------------------
//
// The SVGs under docs/diagrams are parsed out of this source tree rather than drawn,
// so they cannot quietly disagree with the code the way a hand-maintained diagram
// does. The mermaid graph in docs/ARCHITECTURE.md is the complementary half: it shows
// the pipeline as *intended*, these show it as *written*.
//
// Regenerate with `./gradlew diagrams` and commit the result alongside the change.
def codekartaDiagrams = [
        [task : 'diagramModelClasses',
         input: 'src/main/java/se/deversity/skill3/model',
         out  : 'model-class-diagram.svg',
         extra: []],
        [task : 'diagramPipelineClasses',
         input: 'src/main/java/se/deversity/skill3/pipeline',
         out  : 'pipeline-class-diagram.svg',
         extra: []],
        [task : 'diagramLlmClasses',
         input: 'src/main/java/se/deversity/skill3/llm',
         out  : 'llm-class-diagram.svg',
         extra: []],
        [task : 'diagramPipelineSequence',
         input: 'src/main/java/se/deversity/skill3/pipeline',
         out  : 'pipeline-sequence-diagram.svg',
         extra: ['--sequence-only']],
]

def codekartaTasks = codekartaDiagrams.collect { d ->
    tasks.register(d.task, JavaExec) {
        group = 'documentation'
        description = "Render docs/diagrams/${d.out} from ${d.input}"
        classpath = configurations.codekarta
        mainClass = 'se.deversity.codekarta.cli.KartaCli'
        inputs.dir(file(d.input)).withPathSensitivity(PathSensitivity.RELATIVE)
        outputs.file(layout.projectDirectory.file("docs/diagrams/${d.out}"))
        args = ['--input', d.input,
                '--output', 'docs/diagrams',
                '--output-name', d.out] + d.extra
    }
}

tasks.register('diagrams') {
    group = 'documentation'
    description = 'Regenerate every code-karta diagram under docs/diagrams'
    dependsOn codekartaTasks
}