feat: add ktlint linting with Gradle integration, .editorconfig, and CI enforcement

Add ktlint (v12.1.2, engine v1.5.0) via jlleitschuh/ktlint-gradle plugin for
automated Kotlin code style enforcement. Includes .editorconfig with wildcard
import allowlist, disabled trailing comma rules, and 140-char line limit.
CI workflow gets a ktlintCheck step before tests. Applied ktlint formatting
across ~108 source files (mechanical whitespace/blank line changes only).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: jpicklyk

.claude/settings.json

@@ -1,5 +1,3 @@
 {
-  "enabledPlugins": {
-    "task-orchestrator@task-orchestrator-marketplace": true
-  }
+  "enabledPlugins": {}
 }

.editorconfig

@@ -0,0 +1,23 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 4
+
+[*.{kt,kts}]
+# Allow wildcard imports for heavily-used packages
+ij_kotlin_packages_to_use_import_on_demand = kotlinx.serialization.json.*,io.github.jpicklyk.mcptask.current.domain.model.*,io.github.jpicklyk.mcptask.current.application.tools.*,io.mockk.*,io.modelcontextprotocol.kotlin.sdk.types.*,kotlin.test.*,org.junit.jupiter.api.Assertions.*
+
+# Disable trailing comma enforcement (codebase doesn't use them)
+ktlint_standard_trailing-comma-on-call-site = disabled
+ktlint_standard_trailing-comma-on-declaration-site = disabled
+
+# Line length
+max_line_length = 140
+
+[*.md]
+trim_trailing_whitespace = false

.github/workflows/test.yml

@@ -28,6 +28,9 @@ jobs:
     - name: Make gradlew executable
       run: chmod +x gradlew
 
+    - name: Lint check
+      run: ./gradlew :current:ktlintCheck --no-daemon
+
     - name: Run tests
       run: ./gradlew :current:test --no-daemon
 

build.gradle.kts

@@ -5,6 +5,7 @@
 plugins {
     alias(libs.plugins.kotlin.jvm) apply false
     alias(libs.plugins.kotlin.serialization) apply false
+    alias(libs.plugins.ktlint) apply false
 }
 
 allprojects {

current/build.gradle.kts

@@ -3,6 +3,17 @@ import java.util.Properties
 plugins {
     alias(libs.plugins.kotlin.jvm)
     alias(libs.plugins.kotlin.serialization)
+    alias(libs.plugins.ktlint)
+}
+
+ktlint {
+    version.set("1.5.0")
+    android.set(false)
+    outputToConsole.set(true)
+    ignoreFailures.set(false)
+    filter {
+        exclude("**/generated/**")
+    }
 }
 
 // Load version from centralized version.properties
@@ -23,17 +34,18 @@ tasks.register("printTagVersion") {
 }
 
 // Generate build-info resource so the app can read its version at runtime
-val generateBuildInfo = tasks.register("generateBuildInfo") {
-    val outputDir = layout.buildDirectory.dir("generated/resources/build-info")
-    val versionValue = version.toString()
-    inputs.property("version", versionValue)
-    outputs.dir(outputDir)
-    doLast {
-        val dir = outputDir.get().asFile.resolve("build-info")
-        dir.mkdirs()
-        dir.resolve("version.properties").writeText("version=$versionValue\n")
+val generateBuildInfo =
+    tasks.register("generateBuildInfo") {
+        val outputDir = layout.buildDirectory.dir("generated/resources/build-info")
+        val versionValue = version.toString()
+        inputs.property("version", versionValue)
+        outputs.dir(outputDir)
+        doLast {
+            val dir = outputDir.get().asFile.resolve("build-info")
+            dir.mkdirs()
+            dir.resolve("version.properties").writeText("version=$versionValue\n")
+        }
     }
-}
 sourceSets.main { resources.srcDir(generateBuildInfo) }
 
 group = "io.github.jpicklyk"
@@ -105,7 +117,8 @@ tasks.jar {
 
     dependsOn(configurations.runtimeClasspath)
     from({
-        configurations.runtimeClasspath.get()
+        configurations.runtimeClasspath
+            .get()
             .filter { it.name.endsWith("jar") }
             .map { zipTree(it) }
     })

current/src/main/kotlin/io/github/jpicklyk/mcptask/current/CurrentMain.kt

@@ -28,10 +28,12 @@ fun main() {
         SignalHandler.install(coordinator)
 
         // Register JVM shutdown hook as fallback
-        Runtime.getRuntime().addShutdownHook(Thread {
-            coordinator.initiateShutdown("JVM shutdown hook")
-            coordinator.awaitCompletion(5000)
-        })
+        Runtime.getRuntime().addShutdownHook(
+            Thread {
+                coordinator.initiateShutdown("JVM shutdown hook")
+                coordinator.awaitCompletion(5000)
+            }
+        )
 
         // Create and run the MCP server (blocks until server closes)
         val mcpServer = CurrentMcpServer(version, coordinator)

current/src/main/kotlin/io/github/jpicklyk/mcptask/current/application/service/CascadeDetector.kt

@@ -42,7 +42,6 @@ data class UnblockedItem(
  *    whose incoming blocking dependencies are now fully satisfied.
  */
 class CascadeDetector {
-
     companion object {
         /** Maximum ancestor depth for recursive cascade detection. */
         const val MAX_DEPTH = 3
@@ -85,10 +84,11 @@ class CascadeDetector {
 
         // Get role counts for all children of the parent
         val countsResult = workItemRepository.countChildrenByRole(parentId)
-        val roleCounts = when (countsResult) {
-            is Result.Success -> countsResult.data
-            is Result.Error -> return emptyList()
-        }
+        val roleCounts =
+            when (countsResult) {
+                is Result.Success -> countsResult.data
+                is Result.Error -> return emptyList()
+            }
 
         // If there are no children at all, no cascade
         if (roleCounts.isEmpty()) return emptyList()
@@ -99,26 +99,29 @@ class CascadeDetector {
 
         // All children are terminal -- create cascade event for the parent
         val parentResult = workItemRepository.getById(parentId)
-        val parent = when (parentResult) {
-            is Result.Success -> parentResult.data
-            is Result.Error -> return emptyList()
-        }
+        val parent =
+            when (parentResult) {
+                is Result.Success -> parentResult.data
+                is Result.Error -> return emptyList()
+            }
 
         // If parent is already terminal, no cascade needed
         if (parent.role == Role.TERMINAL) return emptyList()
 
-        val event = CascadeEvent(
-            itemId = parent.id,
-            currentRole = parent.role,
-            targetRole = Role.TERMINAL
-        )
+        val event =
+            CascadeEvent(
+                itemId = parent.id,
+                currentRole = parent.role,
+                targetRole = Role.TERMINAL
+            )
 
         // Recursively check the parent's parent
-        val upstreamEvents = if (parent.parentId != null) {
-            detectCascadesRecursive(parent.parentId, workItemRepository, depth + 1)
-        } else {
-            emptyList()
-        }
+        val upstreamEvents =
+            if (parent.parentId != null) {
+                detectCascadesRecursive(parent.parentId, workItemRepository, depth + 1)
+            } else {
+                emptyList()
+            }
 
         return listOf(event) + upstreamEvents
     }
@@ -146,19 +149,22 @@ class CascadeDetector {
 
         // Fetch parent
         val parentResult = workItemRepository.getById(parentId)
-        val parent = when (parentResult) {
-            is Result.Success -> parentResult.data
-            is Result.Error -> return emptyList()
-        }
+        val parent =
+            when (parentResult) {
+                is Result.Success -> parentResult.data
+                is Result.Error -> return emptyList()
+            }
 
         // Parent must be in QUEUE to cascade
         if (parent.role != Role.QUEUE) return emptyList()
 
-        return listOf(CascadeEvent(
-            itemId = parent.id,
-            currentRole = parent.role,
-            targetRole = Role.WORK
-        ))
+        return listOf(
+            CascadeEvent(
+                itemId = parent.id,
+                currentRole = parent.role,
+                targetRole = Role.WORK
+            )
+        )
     }
 
     // -----------------------------------------------------------------------
@@ -180,19 +186,22 @@ class CascadeDetector {
 
         val parentId = item.parentId ?: return emptyList()
 
-        val parent = when (val result = workItemRepository.getById(parentId)) {
-            is Result.Success -> result.data
-            is Result.Error -> return emptyList()
-        }
+        val parent =
+            when (val result = workItemRepository.getById(parentId)) {
+                is Result.Success -> result.data
+                is Result.Error -> return emptyList()
+            }
 
         // Only cascade if parent is TERMINAL
         if (parent.role != Role.TERMINAL) return emptyList()
 
-        return listOf(CascadeEvent(
-            itemId = parent.id,
-            currentRole = Role.TERMINAL,
-            targetRole = Role.WORK
-        ))
+        return listOf(
+            CascadeEvent(
+                itemId = parent.id,
+                currentRole = Role.TERMINAL,
+                targetRole = Role.WORK
+            )
+        )
     }
 
     // -----------------------------------------------------------------------
@@ -230,10 +239,11 @@ class CascadeDetector {
             if (isFullyUnblocked(targetId, dependencyRepository, workItemRepository)) {
                 // Fetch the target item to get its title
                 val targetResult = workItemRepository.getById(targetId)
-                val targetItem = when (targetResult) {
-                    is Result.Success -> targetResult.data
-                    is Result.Error -> continue
-                }
+                val targetItem =
+                    when (targetResult) {
+                        is Result.Success -> targetResult.data
+                        is Result.Error -> continue
+                    }
                 unblockedItems.add(UnblockedItem(itemId = targetItem.id, title = targetItem.title))
             }
         }
@@ -260,10 +270,11 @@ class CascadeDetector {
 
             // Get the blocker's current state
             val blockerResult = workItemRepository.getById(dep.fromItemId)
-            val blockerItem = when (blockerResult) {
-                is Result.Success -> blockerResult.data
-                is Result.Error -> return false // Missing blocker counts as still blocked
-            }
+            val blockerItem =
+                when (blockerResult) {
+                    is Result.Success -> blockerResult.data
+                    is Result.Error -> return false // Missing blocker counts as still blocked
+                }
 
             // If the blocker hasn't reached the threshold, this item is still blocked
             if (!Role.isAtOrBeyond(blockerItem.role, thresholdRole)) {

current/src/main/kotlin/io/github/jpicklyk/mcptask/current/application/service/ItemHierarchyValidator.kt

@@ -15,7 +15,6 @@ import java.util.UUID
  * - Maximum depth enforcement
  */
 class ItemHierarchyValidator {
-
     companion object {
         /** Maximum allowed nesting depth for WorkItems. */
         const val MAX_DEPTH = 3
@@ -49,11 +48,12 @@ class ItemHierarchyValidator {
         val visited = mutableSetOf<UUID>()
         var cursor: UUID? = parentId
         while (cursor != null && visited.size <= MAX_DEPTH) {
-            if (!visited.add(cursor)) break  // Pre-existing cycle — stop walking
-            val ancestor = when (val ancestorResult = repo.getById(cursor)) {
-                is Result.Success -> ancestorResult.data
-                is Result.Error -> break
-            }
+            if (!visited.add(cursor)) break // Pre-existing cycle — stop walking
+            val ancestor =
+                when (val ancestorResult = repo.getById(cursor)) {
+                    is Result.Success -> ancestorResult.data
+                    is Result.Error -> break
+                }
             if (ancestor.id == itemId) {
                 throw ToolValidationException(
                     "$errorPrefix: reparenting to '$parentId' would create a circular hierarchy"

current/src/main/kotlin/io/github/jpicklyk/mcptask/current/application/service/NoteSchemaService.kt

@@ -12,7 +12,6 @@ import io.github.jpicklyk.mcptask.current.domain.model.NoteSchemaEntry
  * return null / false, and transitions proceed without gate enforcement.
  */
 interface NoteSchemaService {
-
     /**
      * Returns the schema entries for the first tag in [tags] that matches a
      * declared schema, or null if no schema matches (schema-free mode).
@@ -24,8 +23,7 @@ interface NoteSchemaService {
      * Used to determine whether `start` from WORK should advance to REVIEW or jump to TERMINAL.
      * Returns false when no schema matches (schema-free mode — skip REVIEW).
      */
-    fun hasReviewPhase(tags: List<String>): Boolean =
-        getSchemaForTags(tags)?.any { it.role == "review" } ?: false
+    fun hasReviewPhase(tags: List<String>): Boolean = getSchemaForTags(tags)?.any { it.role == "review" } ?: false
 }
 
 /**

current/src/main/kotlin/io/github/jpicklyk/mcptask/current/application/service/PhaseNoteContext.kt

@@ -45,10 +45,11 @@ fun computePhaseNoteContext(
 
     val roleStr = role.name.lowercase()
     val required = schema.filter { it.role == roleStr && it.required }
-    val missing = required.filter { entry ->
-        val note = notesByKey[entry.key]
-        note == null || note.body.isBlank()
-    }
+    val missing =
+        required.filter { entry ->
+            val note = notesByKey[entry.key]
+            note == null || note.body.isBlank()
+        }
 
     return PhaseNoteContext(
         guidancePointer = missing.firstOrNull()?.guidance,