refactor argument system

- arguments can have multiple names simultaneously
- argument values can be passed using spaces (e.g., --arg value)
- single-character arguments can be passed using a single dash (e.g., --a -> -a)
- multiple single-character arguments can be combined (e.g., -a -b -> -ab)
- simplify custom arguments using generic classes

src/commonMain/kotlin/com/infendro/cli/argument/Argument.kt

@@ -1,51 +1,44 @@
 package com.infendro.cli.argument
 
-sealed class Argument<T> {
+import com.infendro.cli.exception.build.NoArgumentNameException
-    abstract val name: String
-    abstract val min: Int
-    abstract val max: Int
 
-    abstract class Single<T> : Argument<T>() {
+sealed class Argument<T>(
-        final override val min: Int
+    val names: List<String>,
-            get() = 1
+    val parser: Parser<T>,
-        final override val max: Int
+) {
-            get() = 1
+    abstract val required: Boolean
 
-        abstract val parser: Parser<T>
+    val name: String
-    }
+        get() = names[0]
 
-    abstract class SingleOrElse<T> : Argument<T>() {
+    init {
-        abstract val other: T
+        if (names.isEmpty())
-
+            throw NoArgumentNameException()
-        final override val min: Int
-            get() = 0
-        final override val max: Int
-            get() = 1
-
-        abstract val parser: Parser<T>
-    }
-
-    abstract class SingleOrNull<T> : Argument<T>() {
-        final override val min: Int
-            get() = 0
-        final override val max: Int
-            get() = 1
-
-        abstract val parser: Parser<T>
-    }
-
-    abstract class Multiple<T> : Argument<List<T>>() {
-        override val min: Int
-            get() = 0
-        override val max: Int
-            get() = Int.MAX_VALUE
-
-        abstract val parser: Parser<T>
     }
 
     interface Parser<T> {
-        fun parse(
+        fun parse(text: String?): T
-            text: String?,
+    }
-        ): T
+
+    class Single<T>(
+        names: List<String>,
+        parser: Parser<T>,
+    ) : Argument<T>(names, parser) {
+        override val required: Boolean = true
+    }
+
+    class SingleOrElse<T>(
+        names: List<String>,
+        parser: Parser<T>,
+        val other: T,
+    ) : Argument<T>(names, parser) {
+        override val required: Boolean = false
+    }
+
+    class SingleOrNull<T>(
+        names: List<String>,
+        parser: Parser<T>,
+    ) : Argument<T>(names, parser) {
+        override val required: Boolean = false
     }
 }

src/commonMain/kotlin/com/infendro/cli/argument/Boolean.kt

@@ -1,84 +1,30 @@
 package com.infendro.cli.argument
 
 import com.infendro.cli.command.Command
+import com.infendro.cli.exception.run.ParseException
 
-private object BooleanParser : Argument.Parser<Boolean> {
+object BooleanParser : Argument.Parser<Boolean> {
-    override fun parse(
+    override fun parse(text: String?): Boolean = try {
-        text: String?,
+        text?.toBooleanStrict() ?: true
-    ): Boolean {
+    } catch (_: IllegalArgumentException) {
-        return text == null || text.toBooleanStrict()
+        throw ParseException(text, "Boolean")
     }
 }
 
-class BooleanArgument(
+fun boolean(vararg names: String) =
-    override val name: String,
+    Argument.Single(names.asList(), BooleanParser)
-) : Argument.Single<Boolean>() {
-    override val parser: Parser<Boolean>
-        get() = BooleanParser
-}
 
-fun boolean(
+fun booleanOrElse(vararg names: String, other: Boolean) =
-    name: String,
+    Argument.SingleOrElse(names.asList(), BooleanParser, other)
-) = BooleanArgument(name)
 
-fun Command.Builder.boolean(
+fun booleanOrNull(vararg names: String) =
-    name: String,
+    Argument.SingleOrNull(names.asList(), BooleanParser)
-) = BooleanArgument(name)
-    .also { argument(it) }
 
-class BooleanOrElseArgument(
+fun Command.Builder.boolean(vararg names: String) =
-    override val name: String,
+    Argument.Single(names.asList(), BooleanParser).also { argument(it) }
-    override val other: Boolean,
-) : Argument.SingleOrElse<Boolean>() {
-    override val parser: Parser<Boolean>
-        get() = BooleanParser
-}
 
-fun booleanOrElse(
+fun Command.Builder.booleanOrElse(vararg names: String, other: Boolean) =
-    name: String,
+    Argument.SingleOrElse(names.asList(), BooleanParser, other).also { argument(it) }
-    other: Boolean,
-) = BooleanOrElseArgument(name, other)
 
-fun Command.Builder.booleanOrElse(
+fun Command.Builder.booleanOrNull(vararg names: String) =
-    name: String,
+    Argument.SingleOrNull(names.asList(), BooleanParser).also { argument(it) }
-    other: Boolean,
-) = BooleanOrElseArgument(name, other)
-    .also { argument(it) }
-
-class BooleanOrNullArgument(
-    override val name: String,
-) : Argument.SingleOrNull<Boolean>() {
-    override val parser: Parser<Boolean>
-        get() = BooleanParser
-}
-
-fun booleanOrNull(
-    name: String,
-) = BooleanOrNullArgument(name)
-
-fun Command.Builder.booleanOrNull(
-    name: String,
-) = BooleanOrNullArgument(name)
-    .also { argument(it) }
-
-class BooleansArgument(
-    override val name: String,
-    override val min: Int = 0,
-    override val max: Int = Int.MAX_VALUE,
-) : Argument.Multiple<Boolean>() {
-    override val parser: Parser<Boolean>
-        get() = BooleanParser
-}
-
-fun booleans(
-    name: String,
-    min: Int = 0,
-    max: Int = Int.MAX_VALUE,
-) = BooleansArgument(name, min, max)
-
-fun Command.Builder.booleans(
-    name: String,
-    min: Int = 0,
-    max: Int = Int.MAX_VALUE,
-) = BooleansArgument(name, min, max)
-    .also { argument(it) }

src/commonMain/kotlin/com/infendro/cli/argument/Int.kt

@@ -1,84 +1,33 @@
 package com.infendro.cli.argument
 
 import com.infendro.cli.command.Command
+import com.infendro.cli.exception.run.ParseException
 
-private object IntParser : Argument.Parser<Int> {
+object IntParser : Argument.Parser<Int> {
-    override fun parse(
+    override fun parse(text: String?): Int = try {
-        text: String?,
+        text!!.toInt()
-    ): Int {
+    } catch (e: Exception) {
-        return text!!.toInt()
+        when (e) {
+            is NullPointerException, is IllegalArgumentException -> throw ParseException(text, "Int")
+            else -> throw e
+        }
     }
 }
 
-class IntArgument(
+fun int(vararg names: String) =
-    override val name: String,
+    Argument.Single(names.asList(), IntParser)
-) : Argument.Single<Int>() {
-    override val parser: Parser<Int>
-        get() = IntParser
-}
 
-fun int(
+fun intOrElse(vararg names: String, other: Int) =
-    name: String,
+    Argument.SingleOrElse(names.asList(), IntParser, other)
-) = IntArgument(name)
 
-fun Command.Builder.int(
+fun intOrNull(vararg names: String) =
-    name: String,
+    Argument.SingleOrNull(names.asList(), IntParser)
-) = IntArgument(name)
-    .also { argument(it) }
 
-class IntOrElseArgument(
+fun Command.Builder.int(vararg names: String) =
-    override val name: String,
+    Argument.Single(names.asList(), IntParser).also { argument(it) }
-    override val other: Int,
-) : Argument.SingleOrElse<Int>() {
-    override val parser: Parser<Int>
-        get() = IntParser
-}
 
-fun intOrElse(
+fun Command.Builder.intOrElse(vararg names: String, other: Int) =
-    name: String,
+    Argument.SingleOrElse(names.asList(), IntParser, other).also { argument(it) }
-    other: Int,
-) = IntOrElseArgument(name, other)
 
-fun Command.Builder.intOrElse(
+fun Command.Builder.intOrNull(vararg names: String) =
-    name: String,
+    Argument.SingleOrNull(names.asList(), IntParser).also { argument(it) }
-    other: Int,
-) = IntOrElseArgument(name, other)
-    .also { argument(it) }
-
-class IntOrNullArgument(
-    override val name: String,
-) : Argument.SingleOrNull<Int>() {
-    override val parser: Parser<Int>
-        get() = IntParser
-}
-
-fun intOrNull(
-    name: String,
-) = IntOrNullArgument(name)
-
-fun Command.Builder.intOrNull(
-    name: String,
-) = IntOrNullArgument(name)
-    .also { argument(it) }
-
-class IntsArgument(
-    override val name: String,
-    override val min: Int = 0,
-    override val max: Int = Int.MAX_VALUE,
-) : Argument.Multiple<Int>() {
-    override val parser: Parser<Int>
-        get() = IntParser
-}
-
-fun ints(
-    name: String,
-    min: Int = 0,
-    max: Int = Int.MAX_VALUE,
-) = IntsArgument(name, min, max)
-
-fun Command.Builder.ints(
-    name: String,
-    min: Int = 0,
-    max: Int = Int.MAX_VALUE,
-) = IntsArgument(name, min, max)
-    .also { argument(it) }

src/commonMain/kotlin/com/infendro/cli/argument/String.kt

@@ -1,84 +1,27 @@
 package com.infendro.cli.argument
 
 import com.infendro.cli.command.Command
+import com.infendro.cli.exception.run.ParseException
 
-private object StringParser : Argument.Parser<String> {
+object StringParser : Argument.Parser<String> {
-    override fun parse(
+    override fun parse(text: String?): String =
-        text: String?,
+        text ?: throw ParseException(text, "String")
-    ): String {
-        return text!!
-    }
 }
 
-class StringArgument(
+fun string(vararg names: String) =
-    override val name: String,
+    Argument.Single(names.asList(), StringParser)
-) : Argument.Single<String>() {
-    override val parser: Parser<String>
-        get() = StringParser
-}
 
-fun string(
+fun stringOrElse(vararg names: String, other: String) =
-    name: String,
+    Argument.SingleOrElse(names.asList(), StringParser, other)
-) = StringArgument(name)
 
-fun Command.Builder.string(
+fun stringOrNull(vararg names: String) =
-    name: String,
+    Argument.SingleOrNull(names.asList(), StringParser)
-) = StringArgument(name)
-    .also { argument(it) }
 
-class StringOrElseArgument(
+fun Command.Builder.string(vararg names: String) =
-    override val name: String,
+    Argument.Single(names.asList(), StringParser).also { argument(it) }
-    override val other: String,
-) : Argument.SingleOrElse<String>() {
-    override val parser: Parser<String>
-        get() = StringParser
-}
 
-fun stringOrElse(
+fun Command.Builder.stringOrElse(vararg names: String, other: String) =
-    name: String,
+    Argument.SingleOrElse(names.asList(), StringParser, other).also { argument(it) }
-    other: String,
-) = StringOrElseArgument(name, other)
 
-fun Command.Builder.stringOrElse(
+fun Command.Builder.stringOrNull(vararg names: String) =
-    name: String,
+    Argument.SingleOrNull(names.asList(), StringParser).also { argument(it) }
-    other: String,
-) = StringOrElseArgument(name, other)
-    .also { argument(it) }
-
-class StringOrNullArgument(
-    override val name: String,
-) : Argument.SingleOrNull<String>() {
-    override val parser: Parser<String>
-        get() = StringParser
-}
-
-fun stringOrNull(
-    name: String,
-) = StringOrNullArgument(name)
-
-fun Command.Builder.stringOrNull(
-    name: String,
-) = StringOrNullArgument(name)
-    .also { argument(it) }
-
-class StringsArgument(
-    override val name: String,
-    override val min: Int = 0,
-    override val max: Int = Int.MAX_VALUE,
-) : Argument.Multiple<String>() {
-    override val parser: Parser<String>
-        get() = StringParser
-}
-
-fun strings(
-    name: String,
-    min: Int = 0,
-    max: Int = Int.MAX_VALUE,
-) = StringsArgument(name, min, max)
-
-fun Command.Builder.strings(
-    name: String,
-    min: Int = 0,
-    max: Int = Int.MAX_VALUE,
-) = StringsArgument(name, min, max)
-    .also { argument(it) }

src/commonMain/kotlin/com/infendro/cli/command/Command.kt

@@ -1,99 +1,37 @@
 package com.infendro.cli.command
 
 import com.infendro.cli.argument.Argument
+import com.infendro.cli.exception.CliException
 import com.infendro.cli.exception.build.*
-import com.infendro.cli.exception.run.ArgumentCountException
-import com.infendro.cli.exception.run.InvalidArgumentException
-import com.infendro.cli.exception.run.UnknownArgumentException
 import com.infendro.cli.exception.run.UnknownCommandException
-import com.infendro.cli.util.Regex.ARGUMENT
 import com.infendro.cli.util.Regex.ARGUMENT_NAME
 import com.infendro.cli.util.Regex.COMMAND_NAME
 
 class Command private constructor(
-    private val index: Int,
+    val name: String?,
-    private val name: String?,
+    val commands: List<Command>,
-    private val commands: List<Command>,
+    val arguments: List<Argument<*>>,
-    private val arguments: List<Argument<*>>,
     private val block: Execution.() -> Unit,
 ) {
-    private val nextIndex: Int
+    fun run(args: Array<String>) = try {
-        get() = index + 1
-
-    fun run(
-        args: Array<String>,
-    ) {
         val index = args.withIndex()
-            .find { (_, value) -> value.startsWith("--") }
+            .firstOrNull { (_, value) -> value.startsWith("-") }
             ?.index ?: args.size
 
         val cmd = args.slice(0..<index)
         val arg = args.slice(index..<args.size)
 
-        try {
+        var command = this
-            run(cmd, arg)
+        for (c in cmd) {
-        } catch (e: UnknownCommandException) {
+            command = command.commands.firstOrNull { it.name == c || it.name == null }
-            println("""unknown command "${e.command}"""")
+                ?: throw UnknownCommandException(c)
-        } catch (e: InvalidArgumentException) {
-            println("""invalid argument "${e.argument}"""")
-        } catch (e: UnknownArgumentException) {
-            println("""unknown argument "${e.argument}"""")
-        } catch (e: ArgumentCountException) {
-            when {
-                e.min == e.max -> println("""argument "${e.argument}" must appear ${e.min} times""")
-                e.max == Int.MAX_VALUE -> println("""argument "${e.argument}" must appear at least ${e.min} times""")
-                else -> println("""argument "${e.argument}" must appear between ${e.min} and ${e.max} times""")
-            }
-        }
         }
 
-    private fun run(
+        val execution = Execution.from(command, cmd, arg)
-        cmd: List<String>,
+        val execute = command.block
-        arg: List<String>,
+        execution.execute()
-    ) {
+    } catch (e: CliException) {
-        if (index == cmd.lastIndex) {
+        println(e.message)
-            Execution(
-                parseCmd(cmd),
-                parseArg(arg),
-            ).block()
-        } else {
-            val command = commands.firstOrNull() { it.name == cmd[nextIndex] || it.name == null }
-                ?: throw UnknownCommandException(cmd[nextIndex])
-            command.run(cmd, arg)
-        }
-    }
-
-    private fun parseCmd(
-        cmd: List<String>,
-    ): List<Execution.Cmd> {
-        return cmd.map { Execution.Cmd(it) }
-    }
-
-    private fun parseArg(
-        arg: List<String>,
-    ): List<Execution.Arg> {
-        val result = mutableListOf<Execution.Arg>()
-
-        for (argument in arg) {
-            val match = ARGUMENT.matchEntire(argument)
-                ?: throw InvalidArgumentException(argument)
-
-            val name = match.groups["name"]!!.value
-            val value = match.groups["value"]?.value
-
-            if (arguments.none { it.name == name })
-                throw UnknownArgumentException(name)
-
-            result += Execution.Arg(name, value)
-        }
-
-        arguments.forEach { argument ->
-            val count = result.count { it.name == argument.name }
-            if (count !in argument.min..argument.max)
-                throw ArgumentCountException(argument.name, argument.min, argument.max)
-        }
-
-        return result
     }
 
     class Builder internal constructor(
@@ -107,46 +45,37 @@ class Command private constructor(
         private val nextIndex: Int
             get() = index + 1
 
-        fun command(
+        fun command(name: String? = null, block: Builder.(Key) -> Unit) {
-            name: String? = null,
+            if (name != null && !name.matches(COMMAND_NAME))
-            block: Builder.(Key) -> Unit,
-        ) {
-            if (name != null && !COMMAND_NAME.matches(name))
                 throw IllegalCommandNameException(name)
 
             if (commands.any { it.name == name })
                 throw DuplicateCommandException(name)
 
             val builder = Builder(nextIndex, name)
-            builder.block(Key(nextIndex))
+            val key = Key(nextIndex)
+            builder.block(key)
             val command = builder.build()
 
             commands.add(command)
         }
 
-        fun argument(
+        fun argument(argument: Argument<*>) {
-            argument: Argument<*>,
+            for (name in argument.names) {
-        ) {
+                if (!name.matches(ARGUMENT_NAME))
-            if (!ARGUMENT_NAME.matches(argument.name))
+                    throw IllegalArgumentNameException(name)
-                throw IllegalArgumentNameException(argument.name)
 
-            if (arguments.any { it.name == argument.name })
+                if (arguments.any { name in it.names })
-                throw DuplicateArgumentException(argument.name)
+                    throw DuplicateArgumentException(name)
+            }
 
             arguments.add(argument)
         }
 
-        fun arguments(
+        fun arguments(vararg arguments: Argument<*>) =
-            vararg arguments: Argument<*>,
+            arguments.forEach(::argument)
-        ) {
-            for (argument in arguments) {
-                argument(argument)
-            }
-        }
 
-        fun execute(
+        fun execute(block: Execution.() -> Unit) {
-            block: Execution.() -> Unit,
-        ) {
             if (this::block.isInitialized)
                 throw DuplicateExecuteException()
 
@@ -157,7 +86,7 @@ class Command private constructor(
             if (!this::block.isInitialized)
                 throw NoExecuteException()
 
-            return Command(index, name, commands, arguments, block)
+            return Command(name, commands, arguments, block)
         }
     }
 

src/commonMain/kotlin/com/infendro/cli/command/Execution.kt

@@ -1,20 +1,92 @@
 package com.infendro.cli.command
 
 import com.infendro.cli.argument.Argument
+import com.infendro.cli.exception.run.DuplicateArgumentException
+import com.infendro.cli.exception.run.MalformedArgumentException
+import com.infendro.cli.exception.run.MissingArgumentException
+import com.infendro.cli.exception.run.UnknownArgumentException
 import kotlin.reflect.KProperty
 
-class Execution(
+class Execution private constructor(
     val commands: List<Cmd>,
     val arguments: List<Arg>,
 ) {
+    companion object {
+        fun from(
+            command: Command,
+            cmd: List<String>,
+            arg: List<String>,
+        ): Execution {
+            val commands = Cmd.from(cmd)
+            val arguments = Arg.from(command, arg)
+            return Execution(commands, arguments)
+        }
+    }
+
     class Cmd(
         val name: String,
-    )
+    ) {
+        companion object {
+            fun from(cmd: List<String>): List<Cmd> = cmd.map { Cmd(it) }
+        }
+    }
 
     class Arg(
         val name: String,
         val value: String?,
-    )
+    ) {
+        companion object {
+            fun from(command: Command, arg: List<String>): List<Arg> = buildList {
+                var i = 0
+                while (i < arg.size) {
+                    val dashes = arg[i].takeWhile { it == '-' }.count()
+                    val trimmed = arg[i].substring(dashes)
+
+                    if (dashes !in 1..2 || trimmed.isEmpty())
+                        throw MalformedArgumentException(arg[i])
+
+                    val (name, value) = when {
+                        trimmed.contains('=') -> {
+                            val (name, value) = trimmed.split('=', limit = 2)
+                            name to value
+                        }
+
+                        else -> {
+                            val next = arg.getOrNull(i + 1)
+                            if (next != null && !next.startsWith('-')) {
+                                i++
+                                trimmed to next
+                            } else {
+                                trimmed to null
+                            }
+                        }
+                    }
+
+                    val names = when {
+                        dashes == 1 -> name.map { "$it" }
+                        else -> listOf(name)
+                    }
+
+                    for (name in names) {
+                        if (command.arguments.none { name in it.names })
+                            throw UnknownArgumentException(name)
+
+                        //TODO parse early
+                        add(Arg(name, value))
+                    }
+                    i++
+                }
+
+                for (argument in command.arguments) {
+                    val count = count { it.name in argument.names }
+                    when {
+                        argument.required && count == 0 -> throw MissingArgumentException(argument.name)
+                        count > 1 -> throw DuplicateArgumentException(argument.name)
+                    }
+                }
+            }
+        }
+    }
 
     operator fun Command.Key.getValue(
         thisRef: Any?,
@@ -24,24 +96,18 @@ class Execution(
     operator fun <T> Argument.Single<T>.getValue(
         thisRef: Any?,
         property: KProperty<*>,
-    ): T = arguments.single { it.name == name }
+    ): T = arguments.single { it.name in names }
         .let { parser.parse(it.value) }
 
     operator fun <T> Argument.SingleOrElse<T>.getValue(
         thisRef: Any?,
         property: KProperty<*>,
-    ): T = arguments.singleOrNull { it.name == name }
+    ): T = arguments.singleOrNull { it.name in names }
         ?.let { parser.parse(it.value) } ?: other
 
     operator fun <T> Argument.SingleOrNull<T>.getValue(
         thisRef: Any?,
         property: KProperty<*>,
-    ): T? = arguments.singleOrNull { it.name == name }
+    ): T? = arguments.singleOrNull { it.name in names }
         ?.let { parser.parse(it.value) }
-
-    operator fun <T> Argument.Multiple<T>.getValue(
-        thisRef: Any?,
-        property: KProperty<*>,
-    ): List<T> = arguments.filter { it.name == name }
-        .map { parser.parse(it.value) }
 }

src/commonMain/kotlin/com/infendro/cli/exception/CliException.kt

@@ -0,0 +1,3 @@
+package com.infendro.cli.exception
+
+abstract class CliException : Exception()

src/commonMain/kotlin/com/infendro/cli/exception/build/NoArgumentNameException.kt

@@ -0,0 +1,3 @@
+package com.infendro.cli.exception.build
+
+class NoArgumentNameException : Exception()

src/commonMain/kotlin/com/infendro/cli/exception/run/ArgumentCountException.kt

@@ -1,7 +0,0 @@
-package com.infendro.cli.exception.run
-
-class ArgumentCountException(
-    val argument: String,
-    val min: Int,
-    val max: Int,
-) : Exception()

src/commonMain/kotlin/com/infendro/cli/exception/run/DuplicateArgumentException.kt

@@ -0,0 +1,10 @@
+package com.infendro.cli.exception.run
+
+import com.infendro.cli.exception.CliException
+
+class DuplicateArgumentException(
+    val argument: String,
+) : CliException() {
+    override val message: String
+        get() = """duplicate argument "$argument""""
+}

src/commonMain/kotlin/com/infendro/cli/exception/run/InvalidArgumentException.kt

@@ -1,5 +0,0 @@
-package com.infendro.cli.exception.run
-
-class InvalidArgumentException(
-    val argument: String,
-) : Exception()

src/commonMain/kotlin/com/infendro/cli/exception/run/MalformedArgumentException.kt

@@ -0,0 +1,10 @@
+package com.infendro.cli.exception.run
+
+import com.infendro.cli.exception.CliException
+
+class MalformedArgumentException(
+    val argument: String,
+) : CliException() {
+    override val message: String
+        get() = """malformed argument "$argument""""
+}

src/commonMain/kotlin/com/infendro/cli/exception/run/MissingArgumentException.kt

@@ -0,0 +1,10 @@
+package com.infendro.cli.exception.run
+
+import com.infendro.cli.exception.CliException
+
+class MissingArgumentException(
+    val argument: String,
+) : CliException() {
+    override val message: String
+        get() = """missing argument "$argument""""
+}

src/commonMain/kotlin/com/infendro/cli/exception/run/ParseException.kt

@@ -0,0 +1,11 @@
+package com.infendro.cli.exception.run
+
+import com.infendro.cli.exception.CliException
+
+class ParseException(
+    val text: String?,
+    val type: String,
+) : CliException() {
+    override val message: String
+        get() = """"$text" cannot be converted to $type"""
+}

src/commonMain/kotlin/com/infendro/cli/exception/run/UnknownArgumentException.kt

@@ -1,5 +1,10 @@
 package com.infendro.cli.exception.run
 
+import com.infendro.cli.exception.CliException
+
 class UnknownArgumentException(
     val argument: String,
-) : Exception()
+) : CliException() {
+    override val message: String
+        get() = """unknown argument "$argument""""
+}

src/commonMain/kotlin/com/infendro/cli/exception/run/UnknownCommandException.kt

@@ -1,5 +1,10 @@
 package com.infendro.cli.exception.run
 
+import com.infendro.cli.exception.CliException
+
 class UnknownCommandException(
     val command: String,
-) : Exception()
+) : CliException() {
+    override val message: String
+        get() = """unknown command "$command""""
+}

src/commonMain/kotlin/com/infendro/cli/util/Regex.kt

@@ -1,7 +1,6 @@
 package com.infendro.cli.util
 
 internal object Regex {
-    val COMMAND_NAME = """[a-z]+(?:-[a-z]+)*""".toRegex()
+    val COMMAND_NAME = Regex("""[a-z]+(?:-[a-z]+)*""")
-    val ARGUMENT_NAME = """[a-z]+(?:[\-.][a-z]+)*""".toRegex()
+    val ARGUMENT_NAME = Regex("""[a-z]+(?:[\-.][a-z]+)*""")
-    val ARGUMENT = """--(?<name>[a-z]+(?:[\-.][a-z]+)*)(?:=(?<value>.*))?""".toRegex()
 }