feat: ktlint enforcement and short UUID prefix lookup fix (#73)

* 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>

* fix: use HEX() for short UUID prefix lookup in SQLite

CAST(blob AS VARCHAR) produces raw bytes in SQLite, not a formatted UUID
string, causing prefix lookups to always return empty results. Switch to
LOWER(HEX(id)) for SQLite and LOWER(RAWTOHEX(id)) for H2, which both
produce dashless lowercase hex strings suitable for LIKE prefix matching.

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

* fix: ktlint formatting for multiline expression in findByIdPrefix

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

---------

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,