     internal static func clearCommands() {
         commands = []
     }
-
-    /**
-        Aliases from one command name to another (e.g. from "-h" to "help" or from "co" to "checkout")
-        - Parameter from: Command name from which the alias should be made (e.g. "-h")
-        - Parameter to: Command name to which the alias should be made (e.g. "help")
-    */
+    
+    /**
+     Aliases from one command name to another (e.g. from "-h" to "help" or from "co" to "checkout")
+     - Parameter from: Command name from which the alias should be made (e.g. "-h")
+     - Parameter to: Command name to which the alias should be made (e.g. "help")
+     */
     public static func alias(from: String, to: String) {
         aliases[from] = to
     }
-
-    /**
-        Removes an alias from one command name to another
-        - Parameter from: Alias source which should be removed
+    
+    /**
+     Removes an alias from one command name to another
+     - Parameter from: Alias source which should be removed
      */
     public static func removeAlias(from: String) {
         aliases.removeValue(forKey: from)
     }
-
+    
     // MARK: - Go
-
-    /**
-        Kicks off the entire CLI process, routing to and executing the command specified by the passed arguments.
-        Uses the arguments passed in the command line.
-
-        - SeeAlso: `debugGoWithArgumentString()` when debugging
-        - Returns: a CLIResult (Int) representing the success of the CLI in routing to and executing the correct
-                    command. Usually should be passed to `exit(result)`
-    */
+    
+    /**
+     Kicks off the entire CLI process, routing to and executing the command specified by the passed arguments.
+     Uses the arguments passed in the command line.
+     
+     - SeeAlso: `debugGoWithArgumentString()` when debugging
+     - Returns: a CLIResult (Int) representing the success of the CLI in routing to and executing the correct
+     command. Usually should be passed to `exit(result)`
+     */
     public static func go() -> CLIResult {
-       return go(with: ArgumentList())
-    }
-
-    /**
-        Kicks off the entire CLI process, routing to and executing the command specified by the passed arguments.
-        Uses the arguments passed in as an argument.
-
-        - Parameter argumentString: the arguments to use when running the CLI
-        - SeeAlso: `go()` when running from the command line
-        - Returns: a CLIResult (Int) representing the success of the CLI in routing to and executing the correct
-                    command. Usually should be passed to `exit(result)`
-    */
+        return go(with: ArgumentList())
+    }
+    
+    /**
+     Kicks off the entire CLI process, routing to and executing the command specified by the passed arguments.
+     Uses the arguments passed in as an argument.
+     
+     - Parameter argumentString: the arguments to use when running the CLI
+     - SeeAlso: `go()` when running from the command line
+     - Returns: a CLIResult (Int) representing the success of the CLI in routing to and executing the correct
+     command. Usually should be passed to `exit(result)`
+     */
     public static func debugGo(with argumentString: String) -> CLIResult {
         print("[Debug Mode]")
         return go(with: ArgumentList(argumentString: argumentString))
     }
-
+    
     @available(*, unavailable, renamed: "debugGo(with:)")
     public static func debugGoWithArgumentString(_ argumentString: String) -> CLIResult {
         return debugGo(with: argumentString)
     }
-
+    
     // MARK: - Privates
-
+    
     private static func go(with arguments: ArgumentList) -> CLIResult {
         do {
             // Step 1: route
             let command = try routeCommand(arguments: arguments)
-
+            
             // Step 2: parse options
             try parseOptions(command: command, arguments: arguments)
             if command.helpFlag?.value == true {
                 return CLIResult.success
             }
-
+            
             // Step 3: parse arguments
             do {
                 try commandArgumentParser.parse(arguments: arguments, for: command)

                printError("An error occurred: \(error.localizedDescription)")
            }
        }

        return CLIResult.error
    }

    private static func routeCommand(arguments: ArgumentList) throws -> Command {
        var availableCommands = commands
        availableCommands.append(helpCommand)
        availableCommands.append(versionCommand)
        helpCommand.availableCommands = availableCommands

        guard let command = router.route(commands: availableCommands, aliases: aliases, arguments: arguments) else {
            if let attemptedCommandName = arguments.head {
                printError("Command \"\(attemptedCommandName)\" not found\n")

                // Only print available commands if passed an unavailable command
                helpCommand.printCLIDescription = false
            }

            try helpCommand.execute()

            throw CLIError.emptyError
        }

        return command
    }

    private static func parseOptions(command: Command, arguments: ArgumentList) throws {
        if command is HelpCommand {
            return
        }
        
        let optionRegistry = OptionRegistry(command: command)

        do {
            try optionParser.recognizeOptions(in: arguments, from: optionRegistry)
        } catch let error as OptionParserError {

        } catch let error as NSError {
            printError("An error occurred: \(error.localizedDescription)")
        }
        
        if helpCommand.executeOnCommandFailure {
            do {
                try helpCommand.execute()
