feature: Add subprocess execution APIs (run/call/spawn) to IO

[xerial]

Summary

• Add IO.run, IO.call, and IO.spawn for subprocess execution in wvlet.uni.io
• CommandResult captures exit code, stdout, and stderr
• ProcessConfig supports working directory, env vars, inheritIO, and stderr redirection
• Process trait for spawned process handle (stdin/stdout/stderr streams, waitFor, destroy)
• JVM/Native: java.lang.ProcessBuilder; JS: throws UnsupportedOperationException
• 11 JVM tests covering all APIs

Test plan

• ./sbt "coreJVM/compile" — compiles
• ./sbt "coreJS/compile" — compiles (stub)
• ./sbt "coreNative/compile" — compiles
• ./sbt "uniJVM/testOnly *IOProcessTest" — 11/11 tests pass
• ./sbt scalafmtAll — formatted

🤖 Generated with Claude Code

[gemini-code-assist]

Code Review

This pull request introduces a unified cross-platform API for subprocess execution across JVM, Scala Native, and Scala.js. The implementation includes a ProcessApi trait with methods for running, calling, and spawning processes, along with configuration options for environment variables and working directories. Review feedback suggests deduplicating the nearly identical JVM and Native implementations into a shared source directory, simplifying the destroyForcibly implementation, and enhancing the Process trait with timeout-based waitFor and exitValue methods to prevent potential hangs.

[gemini-code-assist]

This file is nearly identical to uni-core/.jvm/src/main/scala/wvlet/uni/io/IOCompat.scala. To avoid code duplication and improve maintainability, consider moving the shared code to a common source directory for both JVM and Native platforms. In sbt, you can create a uni-core/.jvm-native/src/main/scala directory for this purpose and place the shared implementation there.

[gemini-code-assist]

This implementation of destroyForcibly can be simplified. The semicolon and () are redundant because Scala automatically discards the return value of a method when the expected return type is Unit.

  override def destroyForcibly(): Unit = process.destroyForcibly()

[gemini-code-assist]

The Process trait could be made more robust by adding a timed waitFor and an exitValue method, similar to java.lang.Process. This is crucial for preventing applications or tests from hanging indefinitely when waiting for a process to complete.

Here's a suggested enhancement:

import java.util.concurrent.TimeUnit

// ... in Process trait
def waitFor(timeout: Long, unit: TimeUnit): Boolean
def exitValue(): Int

This would enable safer process handling, like so:

if (proc.waitFor(5, TimeUnit.SECONDS)) {
  val exitCode = proc.exitValue()
  // ... handle completed process
} else {
  // The process timed out
  proc.destroyForcibly()
}