build: resolve cmake executable at configuration time (#319)

* build: resolve cmake executable at configuration time

GUI-launched IDEs on macOS don't inherit Homebrew's /opt/homebrew/bin PATH,
so the configure/compile Exec tasks invoking `commandLine("cmake", ...)`
can fail with "Cannot run program 'cmake'" even when cmake is installed.
Resolve an absolute cmake path at configuration time via CmakeDetection:
check $CMAKE env var, scan $PATH, then fall back to common install paths
for macOS/Linux/Windows.

* build: require isFile in cmake detection and normalize to absolute path

Address Copilot review nits on #319:

- `File.canExecute()` alone returns true for directories with +x on POSIX,
  so a directory named `cmake` under a PATH entry (or in common install
  locations) could be incorrectly selected. Require `isFile && canExecute()`.
- A relative `$CMAKE` value (e.g. `./cmake-wrapper`) was returned as-is,
  contradicting the "absolute path" KDoc. Normalize all detected candidates
  via `absolutePath`.

Author: devcrocod

buildSrc/src/main/kotlin/multik.cmake-build.gradle.kts

@@ -1,9 +1,11 @@
+import org.jetbrains.kotlinx.multik.builds.CmakeDetection
 import org.jetbrains.kotlinx.multik.builds.HomebrewGccDetection
 import org.jetbrains.kotlinx.multik.builds.HostDetection
 
 val cmakePath = "${rootDir}/multik-openblas/multik_jni"
 val cmakeBuildDir = layout.buildDirectory.dir("cmake-build").map { it.asFile.absolutePath }
 
+val cmakeExecutable = CmakeDetection.executable
 val cmakeCCompiler = System.getenv("CMAKE_C_COMPILER")
     ?: HomebrewGccDetection.cCompiler
     ?: "gcc"
@@ -26,7 +28,7 @@ val configureCmake by tasks.registering(Exec::class) {
     dependsOn(createBuildDir)
 
     val args = mutableListOf(
-        "cmake",
+        cmakeExecutable,
         "-DCMAKE_BUILD_TYPE=Release",
         "-DCMAKE_C_COMPILER=$cmakeCCompiler",
         "-DCMAKE_CXX_COMPILER=$cmakeCxxCompiler",
@@ -46,7 +48,7 @@ val compileCmake by tasks.registering(Exec::class) {
     dependsOn(configureCmake)
 
     val processors = Runtime.getRuntime().availableProcessors().toString()
-    commandLine("cmake", "--build", cmakeBuildDir.get(), "--target", "multik_jni-$targetOS", "--", "-j", processors)
+    commandLine(cmakeExecutable, "--build", cmakeBuildDir.get(), "--target", "multik_jni-$targetOS", "--", "-j", processors)
 }
 
 val copyNativeLibs by tasks.registering {

buildSrc/src/main/kotlin/org/jetbrains/kotlinx/multik/builds/CmakeDetection.kt

@@ -0,0 +1,47 @@
+package org.jetbrains.kotlinx.multik.builds
+
+import java.io.File
+
+/**
+ * Resolves an absolute path to the `cmake` executable.
+ *
+ * The `cmake` Gradle tasks run as `Exec` and inherit the PATH of whatever process launched Gradle.
+ * GUI-launched IDEs on macOS don't pick up Homebrew's `/opt/homebrew/bin`, so `commandLine("cmake", ...)`
+ * can fail with "Cannot run program 'cmake'" even when the binary is installed. Resolving to an
+ * absolute path at configuration time sidesteps PATH inheritance entirely.
+ */
+object CmakeDetection {
+
+    /** Absolute path to `cmake`, or plain `"cmake"` as a last resort. */
+    val executable: String by lazy {
+        System.getenv("CMAKE")?.let(::File)?.takeIf { it.isFile && it.canExecute() }?.absolutePath
+            ?: findOnPath()
+            ?: commonInstallPaths.map(::File).firstOrNull { it.isFile && it.canExecute() }?.absolutePath
+            ?: "cmake"
+    }
+
+    private val commonInstallPaths: List<String> = when {
+        HostDetection.isMacosArm64 -> listOf("/opt/homebrew/bin/cmake", "/usr/local/bin/cmake")
+        HostDetection.isMacosX64 -> listOf("/usr/local/bin/cmake", "/opt/homebrew/bin/cmake")
+        HostDetection.isLinux -> listOf("/usr/bin/cmake", "/usr/local/bin/cmake")
+        HostDetection.isWindows -> listOf(
+            "C:\\Program Files\\CMake\\bin\\cmake.exe",
+            "C:\\Program Files (x86)\\CMake\\bin\\cmake.exe"
+        )
+        else -> emptyList()
+    }
+
+    private fun findOnPath(): String? {
+        val path = System.getenv("PATH") ?: return null
+        val separator = File.pathSeparator
+        val exeNames = if (HostDetection.isWindows) listOf("cmake.exe", "cmake") else listOf("cmake")
+        for (dir in path.split(separator)) {
+            if (dir.isEmpty()) continue
+            for (name in exeNames) {
+                val candidate = File(dir, name)
+                if (candidate.isFile && candidate.canExecute()) return candidate.absolutePath
+            }
+        }
+        return null
+    }
+}